@webex/internal-plugin-metrics 3.3.1 → 3.4.0-next.2

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

@@ -0,0 +1,205 @@
+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('#sendEvent', () => {
+      it('should send correctly shaped behavioral event (check name building and internal tagged event building)', () => {
+        // For some reasons `jest` isn't available when testing form build server - so can't use `jest.fn()` here...
+        const requestCalls = [];
+        const request = function(arg) { requestCalls.push(arg) }
+
+        behavioralMetrics.clientMetricsBatcher.request = request;
+        
+        assert.equal(requestCalls.length, 0)
+        behavioralMetrics.submitBehavioralEvent({ product: "webex", agent: "user", target: "foo", verb: "get", payload: {bar:"gee"} })
+        assert.equal(requestCalls.length, 1)
+        assert.deepEqual(requestCalls[0], {
+          context: {
+            app: {version: 'webex-version'},
+            device: {id: 'deviceId'},
+            locale: 'language',
+            os: {
+              name: getOSNameInternal(),
+              version: getOSVersion(),
+            },
+          },
+          metricName: 'webex.user.foo.get',
+          tags: {
+            browser: getBrowserName(),
+            browserHeight: window.innerHeight,
+            browserVersion: getBrowserVersion(),
+            browserWidth: window.innerWidth,
+            domain: window.location.hostname,
+            inIframe: false,
+            locale: window.navigator.language,
+            os: getOSNameInternal(),
+            bar:"gee"
+          },
+          timestamp: requestCalls[0].timestamp, // This is to bypass time check, which is correctly tested below.
+          type: ['behavioral'],
+        });
+      })
+    })
+
+    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.getBrowserDetails();
+
+        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('#isReadyToSubmitEvents', () => {
+      it('should return true when we have a deviceId, false when deviceId is empty or undefined', async () => {
+        let deviceIdUrl = webex.internal.device.url;
+
+        // testing case w/o device id url first, as the internal deviceId cache would bypass that flow.
+        webex.internal.device.url = "";
+        assert.equal(false, behavioralMetrics.isReadyToSubmitEvents());
+
+        delete webex.internal.device.url;
+        assert.equal(false, behavioralMetrics.isReadyToSubmitEvents());
+
+        webex.internal.device.url = deviceIdUrl;
+        assert.equal(true, behavioralMetrics.isReadyToSubmitEvents());
+      });
+    });
+
+    describe('#createEventObject', () => {
+      it('should build event object correctly', async () => {
+        const res = behavioralMetrics.createTaggedEventObject({
+          type:['behavioral'],
+          name:'webex.user.target.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/business/business-metrics.ts

@@ -0,0 +1,120 @@
+import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
+import {BrowserDetection} from '@webex/common';
+import {BusinessMetrics, config, getOSNameInternal} from '@webex/internal-plugin-metrics';
+import uuid from 'uuid';
+
+//@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('BusinessMetrics', () => {
+    let webex;
+    let now;
+    let businessMetrics: BusinessMetrics;
+
+    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());
+      businessMetrics = new BusinessMetrics({}, {parent: webex});
+      sinon.stub(uuid, 'v4').returns('my-fake-id');
+    });
+
+    afterEach(() => {
+      sinon.restore();
+    });
+
+    describe('#sendEvent', () => {
+      it('should send correctly shaped business event (check name building and internal tagged event building)', () => {
+        // For some reasons `jest` isn't available when testing form build server - so can't use `jest.fn()` here...
+        const requestCalls = [];
+        const request = function(arg) { requestCalls.push(arg) }
+
+        businessMetrics.clientMetricsBatcher.request = request;
+        
+        assert.equal(requestCalls.length, 0)
+        businessMetrics.submitBusinessEvent({ name: "foobar", payload: {bar:"gee"} })
+        assert.equal(requestCalls.length, 1)
+        assert.deepEqual(requestCalls[0], {
+          eventPayload: {
+            context: {
+              app: {version: 'webex-version'},
+              device: {id: 'deviceId'},
+              locale: 'language',
+              os: {
+                name: getOSNameInternal(),
+                version: getOSVersion(),
+              },
+            },
+            metricName: 'foobar',
+            browserDetails: {
+              browser: getBrowserName(),
+              browserHeight: window.innerHeight,
+              browserVersion: getBrowserVersion(),
+              browserWidth: window.innerWidth,
+              domain: window.location.hostname,
+              inIframe: false,
+              locale: window.navigator.language,
+              os: getOSNameInternal(),
+            },
+            timestamp: requestCalls[0].eventPayload.timestamp, // This is to bypass time check, which is checked below.
+            value: {
+              bar: "gee"
+            }
+          },
+          type: ['business'],
+        });
+        assert.isNumber(requestCalls[0].eventPayload.timestamp)
+      })
+    })
+  });
+});

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.ts

@@ -1454,6 +1454,9 @@ describe('internal-plugin-metrics', () => {
             eventData: {webClientDomain: 'whatever'},
             intervals: [{}],
             callingServiceType: 'LOCUS',
+            meetingJoinInfo: {
+              clientSignallingProtocol: 'WebRTC',
+            },
             sourceMetadata: {
               applicationSoftwareType: 'webex-js-sdk',
               applicationSoftwareVersion: 'webex-version',
@@ -1490,6 +1493,9 @@ describe('internal-plugin-metrics', () => {
               eventData: {webClientDomain: 'whatever'},
               intervals: [{}],
               callingServiceType: 'LOCUS',
+              meetingJoinInfo: {
+                clientSignallingProtocol: 'WebRTC',
+              },
               sourceMetadata: {
                 applicationSoftwareType: 'webex-js-sdk',
                 applicationSoftwareVersion: 'webex-version',
@@ -1524,6 +1530,9 @@ describe('internal-plugin-metrics', () => {
             eventData: {webClientDomain: 'whatever'},
             intervals: [{}],
             callingServiceType: 'LOCUS',
+            meetingJoinInfo: {
+              clientSignallingProtocol: 'WebRTC',
+            },
             sourceMetadata: {
               applicationSoftwareType: 'webex-js-sdk',
               applicationSoftwareVersion: 'webex-version',

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,
           },
         },
@@ -406,20 +411,28 @@ describe('internal-plugin-metrics', () => {
       });
     });
 
-    it('calls getBuildType correctly', () => {
-      const getBuildTypeSpy = sinon.spy(CallDiagnosticUtils, 'getBuildType');
-      const markAsTestEvent = true;
-      const webClientDomain = 'https://web.webex.com';
-
-      // just submit any event
-      prepareDiagnosticMetricItem(webex, {
+    it('getBuildType returns correct value', () => {
+      const item: any = {
         eventPayload: {
-          event: {name: 'client.exit.app', eventData: {markAsTestEvent, webClientDomain}},
+          event: {
+            name: 'client.exit.app',
+            eventData: {
+              markAsTestEvent: true,
+              webClientDomain: 'https://web.webex.com'
+            }
+          },
         },
         type: ['diagnostic-event'],
-      });
+      };
 
-      assert.calledOnceWithExactly(getBuildTypeSpy, webClientDomain, markAsTestEvent);
+      // just submit any event
+      prepareDiagnosticMetricItem(webex, item);
+      assert.deepEqual(item.eventPayload.origin.buildType, 'test');
+
+      delete item.eventPayload.origin.buildType;
+      item.eventPayload.event.eventData.markAsTestEvent = false;
+      prepareDiagnosticMetricItem(webex, item);
+      assert.deepEqual(item.eventPayload.origin.buildType, 'prod');
     });
   });
 
@@ -605,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
         );