@webex/internal-plugin-metrics 3.0.0-next.1 → 3.0.0-next.10

package/src/metrics.types.ts

@@ -16,6 +16,10 @@ export type ClientLaunchMethodType = NonNullable<
   RawEvent['origin']['clientInfo']
 >['clientLaunchMethod'];
 
+export type BrowserLaunchMethodType = NonNullable<
+  RawEvent['origin']['clientInfo']
+>['browserLaunchMethod'];
+
 export type SubmitClientEventOptions = {
   meetingId?: string;
   mediaConnections?: any[];
@@ -25,6 +29,7 @@ export type SubmitClientEventOptions = {
   environment?: EnvironmentType;
   newEnvironmentType?: NewEnvironmentType;
   clientLaunchMethod?: ClientLaunchMethodType;
+  browserLaunchMethod?: BrowserLaunchMethodType;
   webexConferenceIdStr?: string;
   globalMeetingId?: string;
 };
@@ -164,5 +169,11 @@ export type BuildClientEventFetchRequestOptions = (args: {
 export type PreComputedLatencies =
   | 'internal.client.pageJMT'
   | 'internal.download.time'
+  | 'internal.get.cluster.time'
   | 'internal.click.to.interstitial'
-  | 'internal.call.init.join.req';
+  | 'internal.refresh.captcha.time'
+  | 'internal.exchange.ci.token.time'
+  | 'internal.get.u2c.time'
+  | 'internal.call.init.join.req'
+  | 'internal.other.app.api.time'
+  | 'internal.api.fetch.intelligence.models';

package/src/new-metrics.ts

@@ -43,6 +43,8 @@ class Metrics extends WebexPlugin {
   constructor(...args) {
     super(...args);
 
+    // @ts-ignore
+    this.callDiagnosticLatencies = new CallDiagnosticLatencies({}, {parent: this.webex});
     this.onReady();
   }
 
@@ -54,8 +56,6 @@ class Metrics extends WebexPlugin {
     this.webex.once('ready', () => {
       // @ts-ignore
       this.callDiagnosticMetrics = new CallDiagnosticMetrics({}, {parent: this.webex});
-      // @ts-ignore
-      this.callDiagnosticLatencies = new CallDiagnosticLatencies({}, {parent: this.webex});
     });
   }
 

package/test/unit/spec/call-diagnostic/call-diagnostic-metrics-batcher.ts

@@ -103,6 +103,12 @@ describe('plugin-metrics', () => {
           webex.internal.newMetrics.callDiagnosticLatencies.getClickToInterstitial = sinon
             .stub()
             .returns(10);
+          webex.internal.newMetrics.callDiagnosticLatencies.getRefreshCaptchaReqResp = sinon
+            .stub()
+            .returns(10);
+          webex.internal.newMetrics.callDiagnosticLatencies.getDownloadIntelligenceModelsReqResp =
+            sinon.stub().returns(42);
+
           const promise = webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
             //@ts-ignore
             {event: {name: 'client.interstitial-window.launched'}}
@@ -119,6 +125,8 @@ describe('plugin-metrics', () => {
             joinTimes: {
               clickToInterstitial: 10,
               meetingInfoReqResp: 10,
+              refreshCaptchaServiceReqResp: 10,
+              downloadIntelligenceModelsReqResp: 42,
             },
           });
           assert.lengthOf(
@@ -131,6 +139,12 @@ describe('plugin-metrics', () => {
           webex.internal.newMetrics.callDiagnosticLatencies.getDiffBetweenTimestamps = sinon
             .stub()
             .returns(10);
+          webex.internal.newMetrics.callDiagnosticLatencies.getU2CTime = sinon
+            .stub()
+            .returns(20);
+          webex.internal.newMetrics.callDiagnosticLatencies.getReachabilityClustersReqResp = sinon
+            .stub()
+            .returns(10);
           const promise = webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
             //@ts-ignore
             {event: {name: 'client.call.initiated'}}
@@ -147,6 +161,8 @@ describe('plugin-metrics', () => {
               meetingInfoReqResp: 10,
               registerWDMDeviceJMT: 10,
               showInterstitialTime: 10,
+              getU2CTime: 20,
+              getReachabilityClustersReqResp: 10
             },
           });
           assert.lengthOf(
@@ -159,9 +175,6 @@ describe('plugin-metrics', () => {
           webex.internal.newMetrics.callDiagnosticLatencies.getDiffBetweenTimestamps = sinon
             .stub()
             .returns(10);
-          webex.internal.newMetrics.callDiagnosticLatencies.getJoinRespSentReceived = sinon
-            .stub()
-            .returns(20);
           webex.internal.newMetrics.callDiagnosticLatencies.getPageJMT = sinon.stub().returns(30);
           webex.internal.newMetrics.callDiagnosticLatencies.getClientJMT = sinon.stub().returns(5);
           webex.internal.newMetrics.callDiagnosticLatencies.getClickToInterstitial = sinon
@@ -191,7 +204,6 @@ describe('plugin-metrics', () => {
               clickToInterstitial: 10,
               interstitialToJoinOK: 10,
               joinReqResp: 10,
-              joinReqSentReceived: 20,
               meetingInfoReqResp: 10,
               pageJmt: 30,
               totalJmt: 20,
@@ -357,9 +369,8 @@ describe('plugin-metrics', () => {
         });
       });
 
-      //TODO: The following two skipped tests needs investigation: https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-485382
       describe('when the request fails', () => {
-        it.skip('does not clear the queue', async () => {
+        it('does not clear the queue', async () => {
           // avoid setting .sent timestamp
           webex.internal.newMetrics.callDiagnosticMetrics.callDiagnosticEventsBatcher.prepareRequest =
             (q) => Promise.resolve(q);
@@ -406,7 +417,7 @@ describe('plugin-metrics', () => {
     });
 
     describe('prepareItem', () => {
-      it.skip('calls prepareDiagnosticMetricItem correctly', async () => {
+      it('calls prepareDiagnosticMetricItem correctly', async () => {
         // avoid setting .sent timestamp
         webex.internal.newMetrics.callDiagnosticMetrics.callDiagnosticEventsBatcher.prepareRequest =
           (q) => Promise.resolve(q);

package/test/unit/spec/call-diagnostic/call-diagnostic-metrics-latencies.ts

@@ -41,11 +41,41 @@ describe('internal-plugin-metrics', () => {
       assert.deepEqual(cdl.latencyTimestamps.get('client.alert.displayed'), now.getTime());
     });
 
-    it('should save latency correctly', () => {
+    it('should save latency correctly by default and overwrites', () => {
       assert.deepEqual(cdl.precomputedLatencies.size, 0);
       cdl.saveLatency('internal.client.pageJMT', 10);
       assert.deepEqual(cdl.precomputedLatencies.size, 1);
       assert.deepEqual(cdl.precomputedLatencies.get('internal.client.pageJMT'), 10);
+      cdl.saveLatency('internal.client.pageJMT', 20);
+      assert.deepEqual(cdl.precomputedLatencies.size, 1);
+      assert.deepEqual(cdl.precomputedLatencies.get('internal.client.pageJMT'), 20);
+    });
+
+    it('should overwrite latency when accumulate is false', () => {
+      assert.deepEqual(cdl.precomputedLatencies.size, 0);
+      cdl.saveLatency('internal.client.pageJMT', 10, false);
+      assert.deepEqual(cdl.precomputedLatencies.size, 1);
+      assert.deepEqual(cdl.precomputedLatencies.get('internal.client.pageJMT'), 10);
+      cdl.saveLatency('internal.client.pageJMT', 20, false);
+      assert.deepEqual(cdl.precomputedLatencies.size, 1);
+      assert.deepEqual(cdl.precomputedLatencies.get('internal.client.pageJMT'), 20);
+    });
+
+    it('should save latency correctly when accumulate is true', () => {
+      assert.deepEqual(cdl.precomputedLatencies.size, 0);
+      cdl.saveLatency('internal.client.pageJMT', 10, true);
+      assert.deepEqual(cdl.precomputedLatencies.size, 1);
+      assert.deepEqual(cdl.precomputedLatencies.get('internal.client.pageJMT'), 10);
+    });
+
+    it('should save latency correctly when accumulate is true and there is existing value', () => {
+      assert.deepEqual(cdl.precomputedLatencies.size, 0);
+      cdl.saveLatency('internal.client.pageJMT', 10);
+      assert.deepEqual(cdl.precomputedLatencies.size, 1);
+      assert.deepEqual(cdl.precomputedLatencies.get('internal.client.pageJMT'), 10);
+      cdl.saveLatency('internal.client.pageJMT', 10, true);
+      assert.deepEqual(cdl.precomputedLatencies.size, 1);
+      assert.deepEqual(cdl.precomputedLatencies.get('internal.client.pageJMT'), 20);
     });
 
     it('should save only first timestamp correctly', () => {
@@ -78,8 +108,13 @@ describe('internal-plugin-metrics', () => {
       cdl.saveTimestamp({key: 'client.alert.displayed'});
       cdl.saveTimestamp({key: 'client.alert.removed'});
       assert.deepEqual(cdl.latencyTimestamps.size, 2);
+      cdl.saveLatency('internal.api.fetch.intelligence.models', 42);
+      assert.deepEqual(cdl.precomputedLatencies.size, 1);
+
       cdl.clearTimestamps();
+
       assert.deepEqual(cdl.latencyTimestamps.size, 0);
+      assert.deepEqual(cdl.precomputedLatencies.size, 0);
     });
 
     it('should calculate diff between timestamps correctly', () => {
@@ -111,6 +146,127 @@ describe('internal-plugin-metrics', () => {
       assert.deepEqual(cdl.getMeetingInfoReqResp(), 10);
     });
 
+    describe('measureLatency', () => {
+      let clock;
+      let saveLatencySpy;
+
+      beforeEach(() => {
+        clock = sinon.useFakeTimers();
+
+        saveLatencySpy = sinon.stub(cdl, 'saveLatency');
+      });
+
+      afterEach(() => {
+        clock.restore();
+        sinon.restore();
+      });
+
+      it('checks measureLatency with accumulate false', async () => {
+        const key = 'internal.client.pageJMT';
+        const accumulate = false;
+
+        const callbackStub = sinon.stub().callsFake(() => {
+          clock.tick(50);
+          return Promise.resolve('test');
+        });
+
+        // accumulate should be false by default
+        const promise = cdl.measureLatency(callbackStub, 'internal.client.pageJMT');
+
+        const resolvedValue = await promise;
+        assert.deepEqual(resolvedValue, 'test');
+        assert.calledOnceWithExactly(callbackStub);
+        assert.calledOnceWithExactly(saveLatencySpy, key, 50, accumulate);
+      });
+
+      it('checks measureLatency with accumulate true', async () => {
+        const key = 'internal.download.time';
+        const accumulate = true;
+        const callbackStub = sinon.stub().callsFake(() => {
+          clock.tick(20);
+          return Promise.resolve('test123');
+        });
+
+        const promise = cdl.measureLatency(callbackStub, 'internal.download.time', accumulate);
+
+        const resolvedValue = await promise;
+        assert.deepEqual(resolvedValue, 'test123');
+        assert.calledOnceWithExactly(callbackStub);
+        assert.calledOnceWithExactly(saveLatencySpy, key, 20, accumulate);
+      });
+
+      it('checks measureLatency when callBack rejects', async () => {
+        const key = 'internal.client.pageJMT';
+        const accumulate = false;
+        const error = new Error('some error');
+        const callbackStub = sinon.stub().callsFake(() => {
+          clock.tick(50);
+          return Promise.reject(error);
+        });
+
+        const promise = cdl.measureLatency(callbackStub, 'internal.client.pageJMT', accumulate);
+
+        const rejectedValue = await assert.isRejected(promise);
+        assert.deepEqual(rejectedValue, error);
+        assert.calledOnceWithExactly(callbackStub);
+        assert.calledOnceWithExactly(saveLatencySpy, key, 50, accumulate);
+      });
+    });
+
+    describe('getRefreshCaptchaReqResp', () => {
+      it('returns undefined when no precomputed value available', () => {
+        assert.deepEqual(cdl.getRefreshCaptchaReqResp(), undefined);
+      });
+
+      it('returns the correct value', () => {
+        cdl.saveLatency('internal.refresh.captcha.time', 123);
+
+        assert.deepEqual(cdl.getRefreshCaptchaReqResp(), 123);
+      });
+
+      it('returns the correct whole number', () => {
+        cdl.saveLatency('internal.refresh.captcha.time', 321.44);
+
+        assert.deepEqual(cdl.getRefreshCaptchaReqResp(), 321);
+      });
+    });
+
+    describe('getReachabilityClustersReqResp', () => {
+      it('returns undefined when no precomputed value available', () => {
+        assert.deepEqual(cdl.getReachabilityClustersReqResp(), undefined);
+      });
+
+      it('returns the correct value', () => {
+        cdl.saveLatency('internal.get.cluster.time', 123);
+
+        assert.deepEqual(cdl.getReachabilityClustersReqResp(), 123);
+      });
+
+      it('returns the correct whole number', () => {
+        cdl.saveLatency('internal.get.cluster.time', 321.44);
+
+        assert.deepEqual(cdl.getReachabilityClustersReqResp(), 321);
+      });
+    });
+
+    describe('getExchangeCITokenJMT', () => {
+      it('returns undefined when no precomputed value available', () => {
+        assert.deepEqual(cdl.getExchangeCITokenJMT(), undefined);
+      });
+
+      it('returns the correct value', () => {
+        cdl.saveLatency('internal.exchange.ci.token.time', 123);
+
+        assert.deepEqual(cdl.getExchangeCITokenJMT(), 123);
+      });
+
+      it('returns the correct whole number', () => {
+        cdl.saveLatency('internal.exchange.ci.token.time', 321.44);
+
+        assert.deepEqual(cdl.getExchangeCITokenJMT(), 321);
+      });
+    });
+
     describe('saveTimestamp', () => {
       afterEach(() => {
         sinon.restore();
@@ -512,9 +668,51 @@ describe('internal-plugin-metrics', () => {
       assert.deepEqual(cdl.getInterstitialToMediaOKJMT(), 10);
     });
 
+    it('calculates getU2CTime correctly', () => {
+      it('returns undefined when no precomputed value available', () => {
+        assert.deepEqual(cdl.getU2CTime(), undefined);
+      });
+
+      it('returns the correct value', () => {
+        cdl.saveLatency('internal.get.u2c.time', 123);
+
+        assert.deepEqual(cdl.getU2CTime(), 123);
+      });
+
+      it('returns the correct whole number', () => {
+        cdl.saveLatency('internal.get.u2c.time', 321.44);
+
+        assert.deepEqual(cdl.getU2CTime(), 321);
+      });
+    });
+
     it('calculates getDownloadTimeJMT correctly', () => {
       cdl.saveLatency('internal.download.time', 1000);
       assert.deepEqual(cdl.getDownloadTimeJMT(), 1000);
     });
+
+    describe('getOtherAppApiReqResp', () => {
+      it('returns undefined when no precomputed value available', () => {
+        assert.deepEqual(cdl.getOtherAppApiReqResp(), undefined);
+      });
+
+      it('returns undefined if it is less than 0', () => {
+        cdl.saveLatency('internal.other.app.api.time', 0);
+
+        assert.deepEqual(cdl.getOtherAppApiReqResp(), undefined);
+      });
+
+      it('returns the correct value', () => {
+        cdl.saveLatency('internal.other.app.api.time', 123);
+
+        assert.deepEqual(cdl.getOtherAppApiReqResp(), 123);
+      });
+
+      it('returns the correct whole number', () => {
+        cdl.saveLatency('internal.other.app.api.time', 321.44);
+
+        assert.deepEqual(cdl.getOtherAppApiReqResp(), 321);
+      });
+    });
   });
 });

package/test/unit/spec/call-diagnostic/call-diagnostic-metrics.ts

@@ -223,6 +223,43 @@ describe('internal-plugin-metrics', () => {
         });
       });
 
+      it('should build origin correctly with browserLaunchMethod', () => {
+        sinon.stub(CallDiagnosticUtils, 'anonymizeIPAddress').returns('1.1.1.1');
+
+        //@ts-ignore
+        const res = cd.getOrigin(
+          {
+            subClientType: 'WEB_APP',
+            clientType: 'TEAMS_CLIENT',
+            newEnvironment: 'test-new-env',
+            clientLaunchMethod: 'url-handler',
+            browserLaunchMethod: 'thinclient',
+          },
+          fakeMeeting.id
+        );
+
+        assert.deepEqual(res, {
+          clientInfo: {
+            browser: getBrowserName(),
+            browserVersion: getBrowserVersion(),
+            clientType: 'TEAMS_CLIENT',
+            clientVersion: 'webex-js-sdk/webex-version',
+            publicNetworkPrefix: '1.1.1.1',
+            localNetworkPrefix: '1.1.1.1',
+            os: getOSNameInternal(),
+            osVersion: getOSVersion(),
+            subClientType: 'WEB_APP',
+            clientLaunchMethod: 'url-handler',
+            browserLaunchMethod: 'thinclient',
+          },
+          environment: 'meeting_evn',
+          newEnvironment: 'test-new-env',
+          name: 'endpoint',
+          networkType: 'unknown',
+          userAgent,
+        });
+      });
+
       it('should build origin correctly with no meeting', () => {
         sinon.stub(CallDiagnosticUtils, 'anonymizeIPAddress').returns('1.1.1.1');
 
@@ -302,6 +339,11 @@ describe('internal-plugin-metrics', () => {
 
     describe('#getIdentifiers', () => {
       it('should build identifiers correctly', () => {
+        webex.internal.device = {
+          ...webex.internal.device,
+          config: {installationId: 'installationId'},
+        };
+
         const res = cd.getIdentifiers({
           mediaConnections: [
             {mediaAgentAlias: 'mediaAgentAlias', mediaAgentGroupId: 'mediaAgentGroupId'},
@@ -315,6 +357,7 @@ describe('internal-plugin-metrics', () => {
           locusId: 'url',
           locusStartTime: 'lastActive',
           locusUrl: 'locus/url',
+          machineId: 'installationId',
           mediaAgentAlias: 'mediaAgentAlias',
           mediaAgentGroupId: 'mediaAgentGroupId',
           orgId: 'orgId',
@@ -498,7 +541,10 @@ describe('internal-plugin-metrics', () => {
     it('should prepare diagnostic event successfully', () => {
       const options = {meetingId: fakeMeeting.id};
       const getOriginStub = sinon.stub(cd, 'getOrigin').returns({origin: 'fake-origin'});
-      const clearEmptyKeysRecursivelyStub = sinon.stub(CallDiagnosticUtils, 'clearEmptyKeysRecursively');
+      const clearEmptyKeysRecursivelyStub = sinon.stub(
+        CallDiagnosticUtils,
+        'clearEmptyKeysRecursively'
+      );
 
       const res = cd.prepareDiagnosticEvent(
         {
@@ -715,7 +761,7 @@ describe('internal-plugin-metrics', () => {
         ]);
       });
 
-      it('should submit client event successfully with correlationId, webexConferenceIdStr and globalMeetingId', async () => {
+      it('should submit client event successfully with correlationId, webexConferenceIdStr and globalMeetingId', () => {
         const prepareDiagnosticEventSpy = sinon.spy(cd, 'prepareDiagnosticEvent');
         const submitToCallDiagnosticsSpy = sinon.spy(cd, 'submitToCallDiagnostics');
         const generateClientEventErrorPayloadSpy = sinon.spy(cd, 'generateClientEventErrorPayload');
@@ -853,11 +899,13 @@ describe('internal-plugin-metrics', () => {
           options
         );
         assert.notCalled(submitToCallDiagnosticsSpy);
-        assert.calledWith(submitToCallDiagnosticsPreLoginSpy, {
+        assert.calledWith(
+          submitToCallDiagnosticsPreLoginSpy,
+          {
             eventId: 'my-fake-id',
             version: 1,
-            origin: { origin: 'fake-origin' },
-            originTime: { triggered: now.toISOString(), sent: 'not_defined_yet' },
+            origin: {origin: 'fake-origin'},
+            originTime: {triggered: now.toISOString(), sent: 'not_defined_yet'},
             senderCountryCode: 'UK',
             event: {
               name: 'client.alert.displayed',
@@ -869,12 +917,14 @@ describe('internal-plugin-metrics', () => {
                 orgId: 'orgId',
                 locusUrl: 'locus-url',
                 webexConferenceIdStr: 'webexConferenceIdStr1',
-                globalMeetingId: 'globalMeetingId1'
+                globalMeetingId: 'globalMeetingId1',
               },
-              eventData: { webClientDomain: 'whatever' },
-              loginType: 'login-ci'
+              eventData: {webClientDomain: 'whatever'},
+              loginType: 'login-ci',
             },
-        }, options.preLoginId);
+          },
+          options.preLoginId
+        );
       });
 
       it('should use meeting loginType if present and meetingId provided', () => {
@@ -1339,7 +1389,7 @@ describe('internal-plugin-metrics', () => {
       });
     });
 
-    describe("#submitToCallDiagnostics", () => {
+    describe('#submitToCallDiagnostics', () => {
       it('should send request to call diagnostic batcher', () => {
         const requestStub = sinon.stub();
         //@ts-ignore
@@ -1348,7 +1398,7 @@ describe('internal-plugin-metrics', () => {
         cd.submitToCallDiagnostics({event: 'test'});
         assert.calledWith(requestStub, {eventPayload: {event: 'test'}, type: ['diagnostic-event']});
       });
-    })
+    });
 
     describe('#submitMQE', () => {
       it('submits the event correctly', () => {
@@ -1801,6 +1851,27 @@ describe('internal-plugin-metrics', () => {
         });
       });
 
+      it('should override custom properties for an unknown error', () => {
+        const error = new Error('bad times');
+
+        (error as any).payloadOverrides = {
+          shownToUser: true,
+          category: 'expected',
+        };
+
+        const res = cd.generateClientEventErrorPayload(error);
+        assert.deepEqual(res, {
+          category: 'expected',
+          errorDescription: 'UnknownError',
+          fatal: true,
+          name: 'other',
+          shownToUser: true,
+          serviceErrorCode: 9999,
+          errorCode: 9999,
+          rawErrorMessage: 'bad times',
+        });
+      });
+
       it('should override custom properties for a NetworkOrCORSError', () => {
         const error = new WebexHttpError.NetworkOrCORSError({
           url: 'https://example.com',
@@ -1942,12 +2013,16 @@ describe('internal-plugin-metrics', () => {
 
       describe('httpStatusCode', () => {
         it('should include httpStatusCode for browser media errors', () => {
-          const res = cd.generateClientEventErrorPayload({name: 'PermissionDeniedError', message: 'bad times', statusCode: 401});
+          const res = cd.generateClientEventErrorPayload({
+            name: 'PermissionDeniedError',
+            message: 'bad times',
+            statusCode: 401,
+          });
           assert.deepEqual(res, {
             category: 'expected',
             errorCode: 4032,
             errorData: {
-              errorName: 'PermissionDeniedError'
+              errorName: 'PermissionDeniedError',
             },
             errorDescription: 'CameraPermissionDenied',
             fatal: true,
@@ -1960,12 +2035,16 @@ describe('internal-plugin-metrics', () => {
         });
 
         it('should include httpStatusCode for SdpOfferCreationErrors', () => {
-          const res = cd.generateClientEventErrorPayload({name: 'SdpOfferCreationError', message: 'bad times', statusCode: 404});
+          const res = cd.generateClientEventErrorPayload({
+            name: 'SdpOfferCreationError',
+            message: 'bad times',
+            statusCode: 404,
+          });
           assert.deepEqual(res, {
             category: 'media',
             errorCode: 2050,
             errorData: {
-              errorName: 'SdpOfferCreationError'
+              errorName: 'SdpOfferCreationError',
             },
             errorDescription: 'SdpOfferCreationError',
             fatal: true,
@@ -1978,7 +2057,11 @@ describe('internal-plugin-metrics', () => {
         });
 
         it('should include httpStatusCode for service error codes', () => {
-          const res = cd.generateClientEventErrorPayload({body: {errorCode: 58400}, message: 'bad times', statusCode: 400});
+          const res = cd.generateClientEventErrorPayload({
+            body: {errorCode: 58400},
+            message: 'bad times',
+            statusCode: 400,
+          });
           assert.deepEqual(res, {
             category: 'signaling',
             errorCode: 4100,
@@ -1993,7 +2076,11 @@ describe('internal-plugin-metrics', () => {
         });
 
         it('should include httpStatusCode for locus service error codes', () => {
-          const res = cd.generateClientEventErrorPayload({body: {errorCode: 2403001}, message: 'bad times', statusCode: 400});
+          const res = cd.generateClientEventErrorPayload({
+            body: {errorCode: 2403001},
+            message: 'bad times',
+            statusCode: 400,
+          });
           assert.deepEqual(res, {
             category: 'expected',
             errorCode: 3007,
@@ -2008,7 +2095,11 @@ describe('internal-plugin-metrics', () => {
         });
 
         it('should include httpStatusCode for meetingInfo service error codes', () => {
-          const res = cd.generateClientEventErrorPayload({body: {data: {meetingInfo: {}}}, message: 'bad times', statusCode: 400});
+          const res = cd.generateClientEventErrorPayload({
+            body: {data: {meetingInfo: {}}},
+            message: 'bad times',
+            statusCode: 400,
+          });
           assert.deepEqual(res, {
             category: 'signaling',
             errorCode: 4100,
@@ -2023,8 +2114,10 @@ describe('internal-plugin-metrics', () => {
         });
 
         it('should include httpStatusCode for network errors', () => {
-          const error = new WebexHttpError.NetworkOrCORSError(
-            {statusCode: 400, options: {service: '', headers: {}}});
+          const error = new WebexHttpError.NetworkOrCORSError({
+            statusCode: 400,
+            options: {service: '', headers: {}},
+          });
           const res = cd.generateClientEventErrorPayload(error);
           assert.deepEqual(res, {
             category: 'network',
@@ -2040,8 +2133,10 @@ describe('internal-plugin-metrics', () => {
         });
 
         it('should include httpStatusCode for unauthorized errors', () => {
-          const error = new WebexHttpError.Unauthorized(
-            {statusCode: 401, options: {service: '', headers: {}}});
+          const error = new WebexHttpError.Unauthorized({
+            statusCode: 401,
+            options: {service: '', headers: {}},
+          });
           const res = cd.generateClientEventErrorPayload(error);
           assert.deepEqual(res, {
             category: 'network',
@@ -2244,7 +2339,7 @@ describe('internal-plugin-metrics', () => {
       });
     });
 
-    describe("#submitToCallDiagnosticsPreLogin", () => {
+    describe('#submitToCallDiagnosticsPreLogin', () => {
       it('should send request to call diagnostic batcher and saves preLoginId', () => {
         const requestStub = sinon.stub();
         //@ts-ignore
@@ -2257,7 +2352,7 @@ describe('internal-plugin-metrics', () => {
         assert.calledWith(cd.preLoginMetricsBatcher.savePreLoginId, preLoginId);
         assert.calledWith(requestStub, {eventPayload: {event: 'test'}, type: ['diagnostic-event']});
       });
-    })
+    });
 
     describe('#isServiceErrorExpected', () => {
       it('returns true for code mapped to "expected"', () => {