parallel and test

Author: fmenezes

src/telemetry/telemetry.ts

@@ -106,38 +106,39 @@ export class Telemetry {
     private async getCommonProperties(): Promise<CommonProperties> {
         if (!this.cachedCommonProperties) {
             let deviceId: string | undefined;
-            try {
-                deviceId = await getDeviceId({
-                    getMachineId: () => this.getRawMachineId(),
-                    onError: (reason, error) => {
-                        switch (reason) {
-                            case "resolutionError":
-                                logger.debug(LogId.telemetryDeviceIdFailure, "telemetry", String(error));
-                                break;
-                            case "timeout":
-                                logger.debug(
-                                    LogId.telemetryDeviceIdTimeout,
-                                    "telemetry",
-                                    "Device ID retrieval timed out"
-                                );
-                                break;
-                            case "abort":
-                                // No need to log in the case of aborts
-                                break;
-                        }
-                    },
-                    abortSignal: this.deviceIdAbortController.signal,
-                });
-            } catch (error: unknown) {
-                const err = error instanceof Error ? error : new Error(String(error));
-                logger.debug(LogId.telemetryDeviceIdFailure, "telemetry", err.message);
-            }
             let containerEnv: boolean | undefined;
             try {
-                containerEnv = await this.getContainerEnv();
+                await Promise.all([
+                    getDeviceId({
+                        getMachineId: () => this.getRawMachineId(),
+                        onError: (reason, error) => {
+                            switch (reason) {
+                                case "resolutionError":
+                                    logger.debug(LogId.telemetryDeviceIdFailure, "telemetry", String(error));
+                                    break;
+                                case "timeout":
+                                    logger.debug(
+                                        LogId.telemetryDeviceIdTimeout,
+                                        "telemetry",
+                                        "Device ID retrieval timed out"
+                                    );
+                                    break;
+                                case "abort":
+                                    // No need to log in the case of aborts
+                                    break;
+                            }
+                        },
+                        abortSignal: this.deviceIdAbortController.signal,
+                    }).then((id) => {
+                        deviceId = id;
+                    }),
+                    this.getContainerEnv().then((env) => {
+                        containerEnv = env;
+                    }),
+                ]);
             } catch (error: unknown) {
                 const err = error instanceof Error ? error : new Error(String(error));
-                logger.debug(LogId.telemetryContainerEnvFailure, "telemetry", err.message);
+                logger.debug(LogId.telemetryDeviceIdFailure, "telemetry", err.message);
             }
             this.cachedCommonProperties = {
                 ...MACHINE_METADATA,
@@ -183,6 +184,9 @@ export class Telemetry {
 
         if (this.flushing) {
             this.eventCache.appendEvents(events ?? []);
+            process.nextTick(() => { // try again if in the middle of a flush
+                this.flush();
+            });
             return;
         }
 
@@ -191,6 +195,10 @@ export class Telemetry {
         try {
             const cachedEvents = this.eventCache.getEvents();
             const allEvents = [...cachedEvents, ...(events ?? [])];
+            if (allEvents.length <= 0) {
+                this.flushing = false;
+                return;
+            }
 
             logger.debug(
                 LogId.telemetryEmitStart,
@@ -212,6 +220,9 @@ export class Telemetry {
                 `Error sending event to client: ${error instanceof Error ? error.message : String(error)}`
             );
             this.eventCache.appendEvents(events ?? []);
+            process.nextTick(() => { // try again
+                this.flush();
+            });
         }
 
         this.flushing = false;

tests/unit/telemetry.test.ts

@@ -84,18 +84,11 @@ describe("Telemetry", () => {
         expect(appendEvents.length).toBe(appendEventsCalls);
 
         if (sendEventsCalledWith) {
-            expect(sendEvents[0]?.[0]).toMatchObject(
-                sendEventsCalledWith.map((event) => ({
-                    ...event,
-                    properties: {
-                        ...event.properties,
-                    },
-                }))
-            );
+            expect(sendEvents[0]?.[0]).toMatchObject(sendEventsCalledWith);
         }
 
         if (appendEventsCalledWith) {
-            expect(appendEvents[0]?.[0]).toEqual(appendEventsCalledWith);
+            expect(appendEvents[0]?.[0]).toMatchObject(appendEventsCalledWith);
         }
     }
 
@@ -227,6 +220,31 @@ describe("Telemetry", () => {
                 });
             });
 
+            it("should send cache new event while sending another event", async () => {
+                const newEvent = createTestEvent({
+                    command: "new-command",
+                    component: "new-component",
+                });
+
+                const newEvent2 = createTestEvent({
+                    command: "new-command-2",
+                    component: "new-component-2",
+                });
+
+                telemetry.emitEvents([newEvent]);
+                telemetry.emitEvents([newEvent2]);
+
+                await nextTick(); // wait for the event to be sent
+
+                verifyMockCalls({
+                    sendEventsCalls: 1,
+                    clearEventsCalls: 1,
+                    appendEventsCalls: 1,
+                    sendEventsCalledWith: [newEvent],
+                    appendEventsCalledWith: [newEvent2],
+                });
+            });
+
             describe("machine ID resolution", () => {
                 it("should successfully resolve the machine ID", async () => {
                     const testEvent = createTestEvent();