@webex/internal-plugin-metrics 3.3.1-next.1 → 3.3.1-next.11

package/test/unit/spec/behavioral/behavioral-metrics.ts

@@ -0,0 +1,164 @@
+import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
+import {BrowserDetection} from '@webex/common';
+import {BehavioralMetrics, config, getOSNameInternal} from '@webex/internal-plugin-metrics';
+import uuid from 'uuid';
+import {merge} from 'lodash';
+
+//@ts-ignore
+global.window = {location: {hostname: 'whatever'}, navigator: {language: 'language'}};
+process.env.NODE_ENV = 'test';
+
+const {getOSVersion, getBrowserName, getBrowserVersion} = BrowserDetection();
+
+describe('internal-plugin-metrics', () => {
+  describe('BehavioralMetrics', () => {
+    let webex;
+    let now;
+    let behavioralMetrics: BehavioralMetrics;
+
+    const tags = {key: 'val'};
+
+    beforeEach(() => {
+      now = new Date();
+
+      webex = {
+        canAuthorize: true,
+        version: 'webex-version',
+        internal: {
+          services: {
+            get: () => 'locus-url',
+          },
+          metrics: {
+            submitClientMetrics: sinon.stub(),
+            config: {...config.metrics},
+          },
+          newMetrics: {},
+          device: {
+            userId: 'userId',
+            url: 'https://wdm-intb.ciscospark.com/wdm/api/v1/devices/deviceId',
+            orgId: 'orgId',
+          },
+        },
+        meetings: {
+          config: {
+            metrics: {
+              clientType: 'TEAMS_CLIENT',
+              subClientType: 'WEB_APP',
+              clientName: 'Cantina',
+            },
+          },
+          geoHintInfo: {
+            clientAddress: '1.3.4.5',
+            countryCode: 'UK',
+          },
+        },
+        credentials: {
+          isUnverifiedGuest: false,
+        },
+        prepareFetchOptions: sinon.stub().callsFake((opts: any) => ({...opts, foo: 'bar'})),
+        request: sinon.stub().resolves({body: {}}),
+        logger: {
+          log: sinon.stub(),
+          error: sinon.stub(),
+        },
+      };
+
+      sinon.createSandbox();
+      sinon.useFakeTimers(now.getTime());
+      behavioralMetrics = new BehavioralMetrics({}, {parent: webex});
+      sinon.stub(uuid, 'v4').returns('my-fake-id');
+    });
+
+    afterEach(() => {
+      sinon.restore();
+    });
+
+    describe('#getContext', () => {
+      it('should build context correctly', () => {
+        const res = behavioralMetrics.getContext();
+
+        assert.deepEqual(res, {
+          app: {
+            version: 'webex-version',
+          },
+          device: {
+            id: 'deviceId',
+          },
+          locale: 'language',
+          os: {
+            name: getOSNameInternal(),
+            version: getOSVersion(),
+          },
+        });
+      });
+    });
+
+    describe('#getDefaultTags', () => {
+      it('should build tags correctly', () => {
+        const res = behavioralMetrics.getDefaultTags();
+
+        assert.deepEqual(res, {
+          browser: getBrowserName(),
+          browserHeight: window.innerHeight,
+          browserVersion: getBrowserVersion(),
+          browserWidth: window.innerWidth,
+          domain: window.location.hostname,
+          inIframe: false,
+          locale: window.navigator.language,
+          os: getOSNameInternal(),
+        });
+      });
+    });
+
+    describe('#isReadyToSubmitBehavioralEvents', () => {
+      it('should return true when we have a deviceId, false when deviceId is empty or undefined', async () => {
+        assert.equal(true, behavioralMetrics.isReadyToSubmitBehavioralEvents());
+
+        webex.internal.device.url = "";
+        assert.equal(false, behavioralMetrics.isReadyToSubmitBehavioralEvents());
+
+        delete webex.internal.device.url;
+        assert.equal(false, behavioralMetrics.isReadyToSubmitBehavioralEvents());
+      });
+    });
+
+    describe('#createEventObject', () => {
+      it('should build event object correctly', async () => {
+        const res = behavioralMetrics.createEventObject({
+          product: 'webex',
+          agent: 'user',
+          target: 'target',
+          verb: 'create',
+          payload: tags,
+        });
+
+        assert.deepEqual(res, {
+          context: {
+            app: {
+              version: 'webex-version',
+            },
+            device: {
+              id: 'deviceId',
+            },
+            locale: 'language',
+            os: {
+              name: getOSNameInternal(),
+              version: getOSVersion(),
+            },
+          },
+          metricName: 'webex.user.target.create',
+          tags: merge(tags, {
+            browser: getBrowserName(),
+            browserVersion: getBrowserVersion(),
+            domain: window.location.hostname,
+            locale: window.navigator.language,
+            os: getOSNameInternal(),
+          }),
+          timestamp: res.timestamp,
+          type: ['behavioral'],
+        });
+      });
+    });
+  });
+});

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

@@ -248,9 +248,15 @@ describe('plugin-metrics', () => {
         });
 
         it('appends the correct join times to the request for client.media.rx.start', async () => {
-          webex.internal.newMetrics.callDiagnosticLatencies.getDiffBetweenTimestamps = sinon
+          webex.internal.newMetrics.callDiagnosticLatencies.getLocalSDPGenRemoteSDPRecv = sinon
+            .stub()
+            .returns(5);
+          webex.internal.newMetrics.callDiagnosticLatencies.getAudioJoinRespRxStart = sinon
             .stub()
             .returns(10);
+          webex.internal.newMetrics.callDiagnosticLatencies.getVideoJoinRespRxStart = sinon
+            .stub()
+            .returns(20);
           const promise = webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
             //@ts-ignore
             {event: {name: 'client.media.rx.start'}}
@@ -265,7 +271,13 @@ describe('plugin-metrics', () => {
           assert.deepEqual(webex.request.getCalls()[0].args[0].body.metrics[0].eventPayload.event, {
             name: 'client.media.rx.start',
             joinTimes: {
-              localSDPGenRemoteSDPRecv: 10,
+              localSDPGenRemoteSDPRecv: 5,
+            },
+            audioSetupDelay: {
+              joinRespRxStart: 10,
+            },
+            videoSetupDelay: {
+              joinRespRxStart: 20,
             },
           });
           assert.lengthOf(
@@ -274,19 +286,16 @@ describe('plugin-metrics', () => {
           );
         });
 
-        it('appends the correct join times to the request for client.media-engine.ready', async () => {
-          webex.internal.newMetrics.callDiagnosticLatencies.getDiffBetweenTimestamps = sinon
-            .stub()
-            .returns(10);
-          webex.internal.newMetrics.callDiagnosticLatencies.getInterstitialToMediaOKJMT = sinon
+        it('appends the correct join times to the request for client.media.tx.start', async () => {
+          webex.internal.newMetrics.callDiagnosticLatencies.getAudioJoinRespTxStart = sinon
             .stub()
             .returns(10);
-          webex.internal.newMetrics.callDiagnosticLatencies.getClickToInterstitial = sinon
+          webex.internal.newMetrics.callDiagnosticLatencies.getVideoJoinRespTxStart = sinon
             .stub()
-            .returns(10);
+            .returns(20);
           const promise = webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
             //@ts-ignore
-            {event: {name: 'client.media-engine.ready'}}
+            {event: {name: 'client.media.tx.start'}}
           );
           await flushPromises();
           clock.tick(config.metrics.batcherWait);
@@ -296,12 +305,12 @@ describe('plugin-metrics', () => {
           //@ts-ignore
           assert.calledOnce(webex.request);
           assert.deepEqual(webex.request.getCalls()[0].args[0].body.metrics[0].eventPayload.event, {
-            name: 'client.media-engine.ready',
-            joinTimes: {
-              totalMediaJMT: 30,
-              interstitialToMediaOKJMT: 10,
-              callInitMediaEngineReady: 10,
-              stayLobbyTime: 10,
+            name: 'client.media.tx.start',
+            audioSetupDelay: {
+              joinRespTxStart: 10,
+            },
+            videoSetupDelay: {
+              joinRespTxStart: 20,
             },
           });
           assert.lengthOf(
@@ -310,13 +319,28 @@ describe('plugin-metrics', () => {
           );
         });
 
-        it('appends the correct audio and video setup delays to the request for client.mediaquality.event', async () => {
+        it('appends the correct join times to the request for client.media-engine.ready', async () => {
           webex.internal.newMetrics.callDiagnosticLatencies.getDiffBetweenTimestamps = sinon
             .stub()
             .returns(10);
+          webex.internal.newMetrics.callDiagnosticLatencies.getInterstitialToMediaOKJMT = sinon
+            .stub()
+            .returns(22);
+          webex.internal.newMetrics.callDiagnosticLatencies.getClickToInterstitial = sinon
+            .stub()
+            .returns(35);
+          webex.internal.newMetrics.callDiagnosticLatencies.getInterstitialToJoinOK = sinon
+            .stub()
+            .returns(5);
+          webex.internal.newMetrics.callDiagnosticLatencies.getInterstitialToJoinOK = sinon
+            .stub()
+            .returns(7);
+            webex.internal.newMetrics.callDiagnosticLatencies.getStayLobbyTime = sinon
+            .stub()
+            .returns(1);
           const promise = webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
             //@ts-ignore
-            {event: {name: 'client.mediaquality.event'}}
+            {event: {name: 'client.media-engine.ready'}}
           );
           await flushPromises();
           clock.tick(config.metrics.batcherWait);
@@ -326,14 +350,12 @@ describe('plugin-metrics', () => {
           //@ts-ignore
           assert.calledOnce(webex.request);
           assert.deepEqual(webex.request.getCalls()[0].args[0].body.metrics[0].eventPayload.event, {
-            name: 'client.mediaquality.event',
-            audioSetupDelay: {
-              joinRespRxStart: 10,
-              joinRespTxStart: 10,
-            },
-            videoSetupDelay: {
-              joinRespRxStart: 10,
-              joinRespTxStart: 10,
+            name: 'client.media-engine.ready',
+            joinTimes: {
+              totalMediaJMT: 61,
+              interstitialToMediaOKJMT: 22,
+              callInitMediaEngineReady: 10,
+              stayLobbyTime: 1,
             },
           });
           assert.lengthOf(
@@ -341,32 +363,6 @@ describe('plugin-metrics', () => {
             0
           );
         });
-
-        it('doesnt include audioSetup and videoSetup delays for other events', async () => {
-          const promise = webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
-            //@ts-ignore
-            {event: {name: 'client.alert.displayed'}}
-          );
-          await flushPromises();
-          clock.tick(config.metrics.batcherWait);
-
-          await promise;
-
-          //@ts-ignore
-          assert.calledOnce(webex.request);
-          assert.deepEqual(
-            webex.request.getCalls()[0].args[0].body.metrics[0].eventPayload.event.audioSetupDelay,
-            undefined
-          );
-          assert.deepEqual(
-            webex.request.getCalls()[0].args[0].body.metrics[0].eventPayload.event.videoSetupDelay,
-            undefined
-          );
-          assert.lengthOf(
-            webex.internal.newMetrics.callDiagnosticMetrics.callDiagnosticEventsBatcher.queue,
-            0
-          );
-        });
       });
 
       describe('when the request fails', () => {

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

@@ -668,7 +668,7 @@ describe('internal-plugin-metrics', () => {
       assert.deepEqual(cdl.getInterstitialToMediaOKJMT(), 10);
     });
 
-    it('calculates getU2CTime correctly', () => {
+    describe('calculates getU2CTime correctly', () => {
       it('returns undefined when no precomputed value available', () => {
         assert.deepEqual(cdl.getU2CTime(), undefined);
       });

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

@@ -7,6 +7,7 @@ import CallDiagnosticLatencies from '../../../../src/call-diagnostic/call-diagno
 import {
   DTLS_HANDSHAKE_FAILED_CLIENT_CODE,
   ICE_FAILED_WITHOUT_TURN_TLS_CLIENT_CODE,
+  ICE_AND_REACHABILITY_FAILED_CLIENT_CODE,
   ICE_FAILED_WITH_TURN_TLS_CLIENT_CODE,
   MISSING_ROAP_ANSWER_CLIENT_CODE,
 } from '../../../../src/call-diagnostic/config';
@@ -374,6 +375,12 @@ describe('internal-plugin-metrics', () => {
           joinTimes: {
             localSDPGenRemoteSDPRecv: undefined,
           },
+          audioSetupDelay: {
+            joinRespRxStart: undefined,
+          },
+          videoSetupDelay: {
+            joinRespRxStart: undefined,
+          },
         },
       ],
       [
@@ -388,14 +395,12 @@ describe('internal-plugin-metrics', () => {
         },
       ],
       [
-        'client.mediaquality.event',
+        'client.media.tx.start',
         {
           audioSetupDelay: {
-            joinRespRxStart: undefined,
             joinRespTxStart: undefined,
           },
           videoSetupDelay: {
-            joinRespRxStart: undefined,
             joinRespTxStart: undefined,
           },
         },
@@ -613,41 +618,47 @@ describe('internal-plugin-metrics', () => {
     [
       {
         signalingState: 'have-local-offer',
-        iceConnectionState: 'connected',
+        iceConnected: false,
         turnServerUsed: true,
         errorCode: MISSING_ROAP_ANSWER_CLIENT_CODE,
+        unreachable: false,
       },
       {
         signalingState: 'stable',
-        iceConnectionState: 'connected',
+        iceConnected: true,
         turnServerUsed: true,
         errorCode: DTLS_HANDSHAKE_FAILED_CLIENT_CODE,
+        unreachable: false,
       },
       {
         signalingState: 'stable',
-        iceConnectionState: 'disconnected',
+        iceConnected: false,
         turnServerUsed: true,
-        errorCode: DTLS_HANDSHAKE_FAILED_CLIENT_CODE,
+        errorCode: ICE_FAILED_WITH_TURN_TLS_CLIENT_CODE,
+        unreachable: false,
       },
       {
         signalingState: 'stable',
-        iceConnectionState: 'failed',
+        iceConnected: false,
         turnServerUsed: true,
-        errorCode: ICE_FAILED_WITH_TURN_TLS_CLIENT_CODE,
+        errorCode: ICE_AND_REACHABILITY_FAILED_CLIENT_CODE,
+        unreachable: true,
       },
       {
         signalingState: 'stable',
-        iceConnectionState: 'failed',
+        iceConnected: false,
         turnServerUsed: false,
         errorCode: ICE_FAILED_WITHOUT_TURN_TLS_CLIENT_CODE,
+        unreachable: false,
       },
-    ].forEach(({signalingState, iceConnectionState, turnServerUsed, errorCode}: any) => {
+    ].forEach(({signalingState, iceConnected, turnServerUsed, errorCode, unreachable}: any) => {
       it('returns expected result', () => {
         assert.deepEqual(
           generateClientErrorCodeForIceFailure({
             signalingState,
-            iceConnectionState,
+            iceConnected,
             turnServerUsed,
+            unreachable,
           }),
           errorCode
         );

package/test/unit/spec/prelogin-metrics-batcher.ts

@@ -9,7 +9,6 @@ import MockWebex from '@webex/test-helper-mock-webex';
 import sinon from 'sinon';
 import FakeTimers from '@sinonjs/fake-timers';
 import {NewMetrics} from '@webex/internal-plugin-metrics';
-import {uniqueId} from 'lodash';
 
 const flushPromises = () => new Promise(setImmediate);
 
@@ -66,6 +65,7 @@ describe('internal-plugin-metrics', () => {
 
         // matching because the request includes a symbol key: value pair and sinon cannot handle to compare it..
         assert.match(webexRequestArgs, {
+          //@ts-ignore
           body: {
             metrics: [
               {