@nordicsemiconductor/pc-nrfconnect-shared 122.0.0 → 124.0.0

package/src/utils/launcherConfig.ts

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2023 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import { type Configuration, inMain } from '../../ipc/launcherConfig';
+
+let cachedConfig: Configuration;
+
+export default () => {
+    if (cachedConfig == null) {
+        cachedConfig = inMain.getConfig();
+    }
+
+    return cachedConfig;
+};

package/src/utils/packageJson.ts

@@ -6,26 +6,68 @@
 
 import {
     type PackageJson,
+    type PackageJsonApp,
     parsePackageJson,
+    parsePackageJsonApp,
 } from '../../ipc/schema/packageJson';
 
-let cache: PackageJson | undefined;
+let cache:
+    | undefined
+    | { type: 'launcher'; data: PackageJson }
+    | { type: 'app'; data: PackageJsonApp };
 
-const parsedPackageJson = () => {
+export const isLauncher = (packageJson = parsedPackageJson()) =>
+    packageJson.name === 'nrfconnect';
+
+const parsedPackageJson = (): PackageJson | PackageJsonApp => {
     if (cache != null) {
-        return cache;
+        return cache.data;
     }
 
-    const parsed = parsePackageJson(process.env.PACKAGE_JSON_OF_APP ?? 'null');
-    if (parsed.success) {
-        cache = parsed.data;
-    } else {
+    const unparsed = process.env.PACKAGE_JSON ?? 'null';
+
+    const parsed = parsePackageJson(unparsed);
+
+    if (!parsed.success) {
         throw new Error(
-            `The env variable PACKAGE_JSON_OF_APP must be defined during bundling (through the bundler settings) with a valid package.json but wasn't. Fix this. Error: ${parsed.error.message}`
+            `The env variable PACKAGE_JSON must be defined during bundling (through the bundler settings) with a valid package.json but wasn't. Error: ${parsed.error.message}`
         );
     }
 
-    return cache;
+    if (isLauncher(parsed.data)) {
+        cache = {
+            type: 'launcher',
+            data: parsed.data,
+        };
+    } else {
+        const parsedAppPackageJson = parsePackageJsonApp(unparsed);
+        if (!parsedAppPackageJson.success) {
+            throw new Error(
+                `The package.json must contain all values required for an app. Error: ${parsedAppPackageJson.error.message}`
+            );
+        }
+
+        cache = {
+            type: 'app',
+            data: parsedAppPackageJson.data,
+        };
+    }
+
+    return cache.data;
 };
 
-export default () => parsedPackageJson();
+export const packageJson = parsedPackageJson;
+
+export const packageJsonApp = () => {
+    parsedPackageJson();
+
+    if (cache?.type !== 'app') {
+        throw new Error(
+            `Required the package.json of an app. Actual content: ${JSON.stringify(
+                cache
+            )}`
+        );
+    }
+
+    return cache.data;
+};

package/src/utils/persistentStore.ts

@@ -10,8 +10,9 @@ import { SerialPortOpenOptions } from 'serialport';
 import { v4 as uuid } from 'uuid';
 
 import { inMain as safeStorage } from '../../ipc/safeStorage';
+import { type Device } from '../Device/deviceSlice';
 import logger from '../logging';
-import packageJson from './packageJson';
+import { packageJson } from './packageJson';
 
 export interface SerialSettings {
     serialPortOptions: Omit<SerialPortOpenOptions<AutoDetectTypes>, 'path'>;
@@ -89,24 +90,30 @@ export const getPersistedSerialPortSettings = (
     return sharedStore.get(`${serialNumber}.${appName}`);
 };
 export const persistTerminalSettings = (
-    serialNumber: string,
+    device: Device,
     vComIndex: number,
     terminalSettings: TerminalSettings
-) =>
-    sharedStore.set(
-        `${serialNumber}.vCom-${vComIndex}.TerminalSettings`,
-        terminalSettings
-    );
+) => {
+    if (device.serialNumber) {
+        sharedStore.set(
+            `${device.serialNumber}.vCom-${vComIndex}.TerminalSettings`,
+            terminalSettings
+        );
+    }
+};
 export const getPersistedTerminalSettings = (
-    serialNumber: string,
+    device: Device,
     vComIndex: number
 ): TerminalSettings | undefined => {
-    logger.info(
-        `Get terminal settings from persistent store ${serialNumber}.vCom-${vComIndex}.TerminalSettings`
-    );
-    return sharedStore.get(
-        `${serialNumber}.vCom-${vComIndex}.TerminalSettings`
-    );
+    if (device.serialNumber) {
+        logger.info(
+            `Get terminal settings from persistent store ${device.serialNumber}.vCom-${vComIndex}.TerminalSettings`
+        );
+        return sharedStore.get(
+            `${device.serialNumber}.vCom-${vComIndex}.TerminalSettings`
+        );
+    }
+    return undefined;
 };
 
 export const persistIsSendingUsageData = (value: boolean) =>

package/src/utils/systemReport.ts

@@ -8,7 +8,7 @@ import fs from 'fs';
 import { EOL } from 'os';
 import path from 'path';
 import pretty from 'prettysize';
-import type Systeminformation from 'systeminformation';
+import si from 'systeminformation';
 
 import NrfutilDeviceLib from '../../nrfutil/device/device';
 import {
@@ -25,8 +25,6 @@ import { getAppDataDir } from './appDirs';
 import { openFile } from './open';
 
 const generalInfoReport = async () => {
-    // eslint-disable-next-line global-require
-    const si = require('systeminformation') as typeof Systeminformation;
     const [
         { manufacturer, model },
         { vendor, version },

package/src/utils/usageData.ts

@@ -4,206 +4,114 @@
  * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
  */
 
-import { ApplicationInsights } from '@microsoft/applicationinsights-web';
-import type Systeminformation from 'systeminformation';
-import winston from 'winston';
+import si from 'systeminformation';
 
-import { isDevelopment } from './environment';
+import { packageJson } from './packageJson';
 import {
     deleteIsSendingUsageData,
-    getIsSendingUsageData,
-    getUsageDataClientId,
     persistIsSendingUsageData,
 } from './persistentStore';
-
-const instrumentationKey = '4b8b1a39-37c7-479e-a684-d4763c7c647c';
-
-interface EventAction {
-    action: string;
-    label?: string;
-}
-
-let eventQueue: EventAction[] = [];
-let insights: ApplicationInsights | undefined;
-
-/**
- * Initialize instance to send user data
- * @param {*} packageJson the app's package json
- *
- * @returns {Promise<void>} void
- */
-export const init = (packageJson: { name: string; version: string }) => {
-    const applicationName = isDevelopment
-        ? `${packageJson.name}-dev`
-        : packageJson.name;
-    const applicationVersion = packageJson.version;
-
-    if (!getIsSendingUsageData()) return;
-
-    const accountId = getUsageDataClientId();
-
-    insights = new ApplicationInsights({
-        config: {
-            instrumentationKey,
-            accountId,
-        },
-    });
-
-    insights.loadAppInsights();
-    insights.trackPageView({ name: applicationName });
-
-    // Add app name and version to every event
-    insights.addTelemetryInitializer(envelope => {
-        const trace = {
-            ...(envelope.ext?.trace ?? {}),
-            name: applicationName,
-        };
-        envelope.ext = { ...envelope.ext, trace };
-        envelope.data = {
-            ...envelope.data,
-            applicationName,
-            applicationVersion,
-        };
+import usageDataCommon, { Metadata } from './usageDataCommon';
+import usageDataMain from './usageDataMain';
+import usageDataRenderer from './usageDataRenderer';
+
+const getFriendlyAppName = () =>
+    packageJson().name.replace('pc-nrfconnect-', '');
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const flattenObject = (obj?: any, parentKey?: string) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let result: any = {};
+
+    if (!obj) return result;
+
+    Object.keys(obj).forEach(key => {
+        const value = obj[key];
+        const newKey = parentKey ? `${parentKey}.${key}` : key;
+        if (typeof value === 'object') {
+            result = { ...result, ...flattenObject(value, newKey) };
+        } else {
+            result[newKey] = value;
+        }
     });
 
-    logger?.debug(
-        `Application Insights for category ${applicationName} has initialized`
-    );
-
-    // Add 5 second delay to prevent inital rendering from beeing frozen.
-    setTimeout(async () => {
-        // eslint-disable-next-line global-require
-        const si = require('systeminformation') as typeof Systeminformation;
-        sendUsageData('architecture', (await si.osInfo()).arch);
-    }, 5_000);
-};
-
-/**
- * Checks if usage report instance is initialized and ready to be sent
- *
- * @returns {Boolean} returns whether the setting is on, off or undefined
- */
-export const isInitialized = () => {
-    logger?.debug(
-        `Usage report instance is${
-            insights !== undefined ? '' : ' not'
-        } initialized`
-    );
-    return insights !== undefined;
-};
-
-/**
- * Check the status of usage data
- *
- * @returns {Boolean | undefined} returns whether the setting is on, off or undefined
- */
-export const isEnabled = () => {
-    const isSendingUsageData = getIsSendingUsageData();
-    logger?.debug(`Usage data is ${isSendingUsageData}`);
-    return isSendingUsageData;
+    return result;
 };
 
-/**
- * Enable sending usage data
- *
- * @returns {void}
- */
-export const enable = () => {
+const enable = () => {
     persistIsSendingUsageData(true);
-    logger?.debug('Usage data has been enabled');
+    si.osInfo().then(({ platform, arch }) =>
+        getUsageData().sendUsageData('Report OS info', { platform, arch })
+    );
+    getUsageData().sendUsageData('Data Usage Opt-In', undefined);
+    usageDataCommon.getLogger()?.debug('Usage data has been enabled');
 };
 
-/**
- * Disable sending usage data
- *
- * @returns {void}
- */
-export const disable = () => {
+const disable = () => {
+    getUsageData().sendUsageData('Data Usage Opt-Out', undefined, true);
     persistIsSendingUsageData(false);
-    logger?.debug('Usage data has been disabled');
+    usageDataCommon.getLogger()?.debug('Usage data has been disabled');
 };
 
-/**
- * Reset settings so that launcher is able to
- * ask the user to enable or disable sending usage data
- *
- * @returns {void}
- */
-export const reset = () => {
+const reset = () => {
+    getUsageData().sendUsageData('Data Usage Opt-Reset', undefined, true);
     deleteIsSendingUsageData();
-    logger?.debug('Usage data setting has been reset');
+    usageDataCommon.getLogger()?.debug('Usage data setting has been reset');
 };
 
-/**
- * Send event
- * @param {EventAction} event the event to send
- *
- * @returns {void}
- */
-const sendEvent = ({ action, label }: EventAction) => {
-    const isSendingUsageData = getIsSendingUsageData();
-
-    if (isSendingUsageData && insights !== undefined) {
-        logger?.debug(`Sending usage data ${action} ${label}`);
-        insights.trackEvent({
-            name: action,
-            properties: label ? { label } : undefined,
-        });
+const isRenderer = process && process.type === 'renderer';
+
+const getUsageData = () => {
+    if (isRenderer) {
+        return usageDataRenderer;
     }
+
+    return usageDataMain;
 };
 
-/**
- * Send usage data event to Application Insights
- * @param {string} action The event action
- * @param {string} label The event label
- * @returns {void}
- */
-export const sendUsageData = <T extends string>(action: T, label?: string) => {
-    eventQueue.push({ action, label });
-    if (!isInitialized()) {
-        return;
+const sendUsageData = async (
+    action: string,
+    metadata?: Metadata,
+    forceSend?: boolean
+) => {
+    if (
+        await getUsageData().sendUsageData(
+            `${getFriendlyAppName()}: ${action}`,
+            flattenObject(metadata),
+            forceSend
+        )
+    ) {
+        usageDataCommon
+            .getLogger()
+            ?.debug(`Sending usage data ${JSON.stringify(action)}`);
     }
-    eventQueue.forEach(sendEvent);
-    eventQueue = [];
 };
 
-export const sendMetric = (name: string, average: number) => {
-    insights?.trackMetric({
-        name,
-        average,
-    });
-};
+const sendPageView = (pageName: string) =>
+    getUsageData().sendPageView(`${getFriendlyAppName()} - ${pageName}`);
 
-export const sendTrace = (message: string) => {
-    insights?.trackTrace({
-        message,
-    });
-};
+const sendMetric = (name: string, average: number) =>
+    getUsageData().sendMetric(name, average);
 
-/**
- * Send error usage data event to Application Insights and also show it in the logger view
- * @param {string} error The event action
- * @returns {void}
- */
-export const sendErrorReport = (error: string) => {
-    logger?.error(error);
-    insights?.trackException({
-        exception: new Error(error),
-    });
-};
+const sendTrace = (message: string) => getUsageData().sendTrace(message);
 
-let logger: winston.Logger | undefined;
-export const setUsageLogger = (log: winston.Logger) => {
-    logger = log;
+const sendErrorReport = (error: string | Error) => {
+    usageDataCommon.getLogger()?.error(error);
+    return getUsageData().sendErrorReport(
+        typeof error === 'string' ? new Error(error) : error
+    );
 };
 
 export default {
+    setLogger: usageDataCommon.setLogger,
     disable,
     enable,
-    init,
-    isEnabled,
-    isInitialized,
+    isEnabled: usageDataCommon.isEnabled,
     reset,
     sendErrorReport,
     sendUsageData,
+    sendPageView,
+    sendMetric,
+    sendTrace,
+    enableTelemetry: usageDataCommon.enableTelemetry,
 };

package/src/utils/usageDataCommon.ts

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2105 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import winston from 'winston';
+
+import { type Device } from '../Device/deviceSlice';
+import { getIsSendingUsageData } from './persistentStore';
+
+export const INSTRUMENTATION_KEY = '4b8b1a39-37c7-479e-a684-d4763c7c647c';
+
+let telemetryEnabled = false;
+
+const enableTelemetry = () => {
+    telemetryEnabled = true;
+};
+
+let logger: winston.Logger | undefined;
+const setLogger = (log: winston.Logger) => {
+    logger = log;
+};
+
+const getLogger = () => logger;
+
+export interface Metadata {
+    [key: string]: unknown;
+}
+
+export const simplifyDeviceForLogging = (device: Device) => ({
+    devkit: device.devkit,
+    serialPorts: device.serialPorts,
+    traits: device.traits,
+    serialNumber: device.serialNumber,
+    enumerationID: device.id,
+    usb: {
+        product: device.usb?.product,
+        manufacturer: device.usb?.manufacturer,
+        deviceDescriptor: device.usb?.device.descriptor,
+    },
+});
+
+const isEnabled = () => {
+    const isSendingUsageData = getShouldSendTelemetry();
+    logger?.debug(`Usage data is ${isSendingUsageData}`);
+    return isSendingUsageData;
+};
+
+const getShouldSendTelemetry = (forceSend?: boolean) =>
+    (forceSend || getIsSendingUsageData()) && telemetryEnabled;
+
+export default {
+    setLogger,
+    getLogger,
+    isEnabled,
+    getShouldSendTelemetry,
+    enableTelemetry,
+};

package/src/utils/usageDataMain.ts

@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2105 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import { TelemetryClient } from 'applicationinsights';
+
+import { isDevelopment } from './environment';
+import { packageJson } from './packageJson';
+import usageDataCommon, {
+    INSTRUMENTATION_KEY,
+    Metadata,
+} from './usageDataCommon';
+
+let cachedInsights: TelemetryClient | undefined;
+
+const getInsights = (forceSend?: boolean) => {
+    if (!usageDataCommon.getShouldSendTelemetry(forceSend)) return;
+
+    if (cachedInsights) {
+        return cachedInsights;
+    }
+
+    if (!cachedInsights) {
+        cachedInsights = init();
+    }
+
+    return cachedInsights;
+};
+
+const init = () => {
+    const appPackageJson = packageJson();
+    const applicationName = appPackageJson.name;
+    const applicationVersion = appPackageJson.version;
+
+    const out = new TelemetryClient(INSTRUMENTATION_KEY);
+    out.config.enableAutoCollectConsole = false;
+    out.config.enableAutoCollectDependencies = false;
+    out.config.enableAutoCollectExceptions = false;
+    out.config.enableAutoCollectIncomingRequestAzureFunctions = false;
+    out.config.enableAutoCollectHeartbeat = false;
+    out.config.enableAutoCollectPerformance = false;
+    out.config.enableAutoCollectPreAggregatedMetrics = false;
+    out.config.enableAutoCollectRequests = false;
+    out.config.enableAutoDependencyCorrelation = false;
+
+    // Add app name and version to every event
+    out.addTelemetryProcessor(envelope => {
+        if (envelope.data.baseData?.removeAllMetadata) {
+            envelope.tags = [];
+            envelope.data.baseData = { name: envelope.data?.baseData };
+        } else {
+            envelope.tags['ai.cloud.roleInstance'] = undefined; // remove PC name
+            envelope.data.baseData = {
+                applicationName,
+                applicationVersion,
+                isDevelopment,
+                ...envelope.data.baseData,
+            };
+        }
+
+        return true;
+    });
+
+    return out;
+};
+
+const sendUsageData = (
+    action: string,
+    metadata?: Metadata,
+    forceSend?: boolean
+) => {
+    const result = getInsights(forceSend);
+    if (result !== undefined) {
+        result.trackEvent({
+            name: action,
+            properties: forceSend ? { removeAllMetadata: true } : metadata,
+        });
+        return true;
+    }
+
+    return false;
+};
+
+const sendPageView = (pageName: string) => {
+    getInsights()?.trackPageView({
+        name: pageName,
+    });
+};
+
+const sendMetric = (name: string, value: number) => {
+    getInsights()?.trackMetric({
+        name,
+        value,
+    });
+};
+
+const sendTrace = (message: string) => {
+    getInsights()?.trackTrace({
+        message,
+    });
+};
+
+const sendErrorReport = (error: Error) => {
+    getInsights()?.trackException({
+        exception: error,
+    });
+};
+
+export default {
+    sendErrorReport,
+    sendUsageData,
+    sendPageView,
+    sendMetric,
+    sendTrace,
+};