@webex/internal-plugin-metrics 3.5.0-next.3 → 3.5.0-next.5

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

@@ -1,7 +1,9 @@
 import sinon from 'sinon';
+import bowser from 'bowser';
 import {assert} from '@webex/test-helper-chai';
 import {WebexHttpError} from '@webex/webex-core';
 import {BrowserDetection} from '@webex/common';
+import window from 'global/window';
 import {
   CallDiagnosticLatencies,
   CallDiagnosticMetrics,
@@ -30,7 +32,6 @@ describe('internal-plugin-metrics', () => {
     const fakeMeeting = {
       id: '1',
       correlationId: 'correlationId',
-      sessionCorrelationId: undefined,
       callStateForMetrics: {},
       environment: 'meeting_evn',
       locusUrl: 'locus/url',
@@ -53,9 +54,17 @@ describe('internal-plugin-metrics', () => {
       callStateForMetrics: {loginType: 'fakeLoginType'},
     };
 
+    const fakeMeeting3 = {
+      ...fakeMeeting,
+      id: '3',
+      correlationId: 'correlationId3',
+      sessionCorrelationId: 'sessionCorrelationId3',
+    }
+
     const fakeMeetings = {
       1: fakeMeeting,
       2: fakeMeeting2,
+      3: fakeMeeting3,
     };
 
     let webex;
@@ -355,7 +364,6 @@ describe('internal-plugin-metrics', () => {
 
         assert.deepEqual(res, {
           correlationId: 'correlationId',
-          sessionCorrelationId: undefined,
           deviceId: 'deviceUrl',
           locusId: 'url',
           locusStartTime: 'lastActive',
@@ -368,7 +376,37 @@ describe('internal-plugin-metrics', () => {
         });
       });
 
-      it('should build identifiers correctly', () => {
+      [undefined, null, '', false, 0].forEach((sessionCorrelationId) => {
+        it(`should build identifiers correctly and not add session correlation id if it is falsy: ${sessionCorrelationId}`, () => {
+          cd.device = {
+            ...cd.device,
+            config: {installationId: 'installationId'},
+          };
+
+          const res = cd.getIdentifiers({
+            mediaConnections: [
+              {mediaAgentAlias: 'mediaAgentAlias', mediaAgentGroupId: 'mediaAgentGroupId'},
+            ],
+            meeting: {...fakeMeeting, sessionCorrelationId},
+            sessionCorrelationId: sessionCorrelationId as any,
+          });
+
+          assert.deepEqual(res, {
+            correlationId: 'correlationId',
+            deviceId: 'deviceUrl',
+            locusId: 'url',
+            locusStartTime: 'lastActive',
+            locusUrl: 'locus/url',
+            machineId: 'installationId',
+            mediaAgentAlias: 'mediaAgentAlias',
+            mediaAgentGroupId: 'mediaAgentGroupId',
+            orgId: 'orgId',
+            userId: 'userId',
+          });
+        });
+      });
+
+      it('should build identifiers correctly with sessionCorrelationID as a param', () => {
         cd.device = {
           ...cd.device,
           config: {installationId: 'installationId'},
@@ -397,6 +435,35 @@ describe('internal-plugin-metrics', () => {
         });
       });
 
+      it('should build identifiers correctly with sessionCorrelationID as a param and a meeting with session correlation id, and the param should take precedence', () => {
+        cd.device = {
+          ...cd.device,
+          config: {installationId: 'installationId'},
+        };
+
+        const res = cd.getIdentifiers({
+          mediaConnections: [
+            {mediaAgentAlias: 'mediaAgentAlias', mediaAgentGroupId: 'mediaAgentGroupId'},
+          ],
+          meeting: {...fakeMeeting, sessionCorrelationId: 'sessionCorrelationId1'},
+          sessionCorrelationId: 'sessionCorrelationId',
+        });
+
+        assert.deepEqual(res, {
+          correlationId: 'correlationId',
+          sessionCorrelationId: 'sessionCorrelationId',
+          deviceId: 'deviceUrl',
+          locusId: 'url',
+          locusStartTime: 'lastActive',
+          locusUrl: 'locus/url',
+          machineId: 'installationId',
+          mediaAgentAlias: 'mediaAgentAlias',
+          mediaAgentGroupId: 'mediaAgentGroupId',
+          orgId: 'orgId',
+          userId: 'userId',
+        });
+      });
+
       it('should build identifiers correctly with a meeting that has meetingInfo with a webexConferenceIdStr and globalMeetingId, and that should take precedence over the options passed to it', () => {
         const res = cd.getIdentifiers({
           mediaConnections: [
@@ -450,7 +517,6 @@ describe('internal-plugin-metrics', () => {
 
         assert.deepEqual(res, {
           correlationId: 'correlationId',
-          sessionCorrelationId: undefined,
           webexConferenceIdStr: 'webexConferenceIdStr1',
           globalMeetingId: 'globalMeetingId1',
           deviceId: 'deviceUrl',
@@ -484,7 +550,6 @@ describe('internal-plugin-metrics', () => {
 
         assert.deepEqual(res, {
           correlationId: 'correlationId',
-          sessionCorrelationId: undefined,
           webexConferenceIdStr: 'webexConferenceIdStr1',
           globalMeetingId: 'globalMeetingId1',
           deviceId: 'deviceUrl',
@@ -543,7 +608,6 @@ describe('internal-plugin-metrics', () => {
 
         assert.deepEqual(res, {
           correlationId: 'correlationId',
-          sessionCorrelationId: 'unknown',
           webexConferenceIdStr: 'webexConferenceIdStr1',
           deviceId: 'deviceUrl',
           locusUrl: 'locus-url',
@@ -560,7 +624,6 @@ describe('internal-plugin-metrics', () => {
 
         assert.deepEqual(res, {
           correlationId: 'correlationId',
-          sessionCorrelationId: 'unknown',
           globalMeetingId: 'globalMeetingId1',
           deviceId: 'deviceUrl',
           locusUrl: 'locus-url',
@@ -576,7 +639,6 @@ describe('internal-plugin-metrics', () => {
 
         assert.deepEqual(res, {
           correlationId: 'correlationId',
-          sessionCorrelationId: 'unknown',
           deviceId: 'deviceUrl',
           locusUrl: 'locus-url',
           orgId: 'orgId',
@@ -621,7 +683,6 @@ describe('internal-plugin-metrics', () => {
 
         assert.deepEqual(res, {
           correlationId: 'correlationId',
-          sessionCorrelationId: 'unknown',
           locusUrl: 'locus-url',
           deviceId: 'deviceUrl',
           orgId: 'orgId',
@@ -695,12 +756,13 @@ describe('internal-plugin-metrics', () => {
           options,
         });
 
+        assert.called(getIdentifiersSpy);
         assert.calledWith(getIdentifiersSpy, {
           meeting: fakeMeeting,
           mediaConnections: [{mediaAgentAlias: 'alias', mediaAgentGroupId: '1'}],
           webexConferenceIdStr: undefined,
-          sessionCorrelationId: undefined,
           globalMeetingId: undefined,
+          sessionCorrelationId: undefined,
         });
         assert.notCalled(generateClientEventErrorPayloadSpy);
         assert.calledWith(
@@ -712,7 +774,6 @@ describe('internal-plugin-metrics', () => {
             },
             identifiers: {
               correlationId: 'correlationId',
-              sessionCorrelationId: undefined,
               deviceId: 'deviceUrl',
               locusId: 'url',
               locusStartTime: 'lastActive',
@@ -738,7 +799,6 @@ describe('internal-plugin-metrics', () => {
             },
             identifiers: {
               correlationId: 'correlationId',
-              sessionCorrelationId: undefined,
               deviceId: 'deviceUrl',
               locusId: 'url',
               locusStartTime: 'lastActive',
@@ -775,7 +835,142 @@ describe('internal-plugin-metrics', () => {
               },
               identifiers: {
                 correlationId: 'correlationId',
-                sessionCorrelationId: undefined,
+                deviceId: 'deviceUrl',
+                locusId: 'url',
+                locusStartTime: 'lastActive',
+                locusUrl: 'locus/url',
+                mediaAgentAlias: 'alias',
+                mediaAgentGroupId: '1',
+                orgId: 'orgId',
+                userId: 'userId',
+              },
+              loginType: 'login-ci',
+              name: 'client.alert.displayed',
+              userType: 'host',
+              isConvergedArchitectureEnabled: undefined,
+              webexSubServiceType: undefined,
+            },
+            eventId: 'my-fake-id',
+            origin: {
+              origin: 'fake-origin',
+            },
+            originTime: {
+              sent: 'not_defined_yet',
+              triggered: now.toISOString(),
+            },
+            senderCountryCode: 'UK',
+            version: 1,
+          },
+        });
+
+        const webexLoggerLogCalls = webex.logger.log.getCalls();
+        assert.deepEqual(webexLoggerLogCalls[1].args, [
+          'call-diagnostic-events -> ',
+          'CallDiagnosticMetrics: @submitClientEvent. Submit Client Event CA event.',
+          `name: client.alert.displayed`,
+        ]);
+      });
+
+      it('should submit client event successfully with meetingId which has a sessionCorrelationId', () => {
+        const prepareDiagnosticEventSpy = sinon.spy(cd, 'prepareDiagnosticEvent');
+        const submitToCallDiagnosticsSpy = sinon.spy(cd, 'submitToCallDiagnostics');
+        const generateClientEventErrorPayloadSpy = sinon.spy(cd, 'generateClientEventErrorPayload');
+        const getIdentifiersSpy = sinon.spy(cd, 'getIdentifiers');
+        const getSubServiceTypeSpy = sinon.spy(cd, 'getSubServiceType');
+        sinon.stub(cd, 'getOrigin').returns({origin: 'fake-origin'});
+        const validatorSpy = sinon.spy(cd, 'validator');
+        const options = {
+          meetingId: fakeMeeting3.id,
+          mediaConnections: [{mediaAgentAlias: 'alias', mediaAgentGroupId: '1'}],
+        };
+
+        cd.submitClientEvent({
+          name: 'client.alert.displayed',
+          options,
+        });
+
+        assert.called(getIdentifiersSpy);
+        assert.calledWith(getIdentifiersSpy, {
+          meeting: {...fakeMeeting3, sessionCorrelationId: 'sessionCorrelationId3'},
+          mediaConnections: [{mediaAgentAlias: 'alias', mediaAgentGroupId: '1'}],
+          webexConferenceIdStr: undefined,
+          globalMeetingId: undefined,
+          sessionCorrelationId: undefined,
+        });
+        assert.notCalled(generateClientEventErrorPayloadSpy);
+        assert.calledWith(
+          prepareDiagnosticEventSpy,
+          {
+            canProceed: true,
+            eventData: {
+              webClientDomain: 'whatever',
+            },
+            identifiers: {
+              correlationId: 'correlationId3',
+              sessionCorrelationId: 'sessionCorrelationId3',
+              deviceId: 'deviceUrl',
+              locusId: 'url',
+              locusStartTime: 'lastActive',
+              locusUrl: 'locus/url',
+              mediaAgentAlias: 'alias',
+              mediaAgentGroupId: '1',
+              orgId: 'orgId',
+              userId: 'userId',
+            },
+            loginType: 'login-ci',
+            name: 'client.alert.displayed',
+            userType: 'host',
+            isConvergedArchitectureEnabled: undefined,
+            webexSubServiceType: undefined,
+          },
+          options
+        );
+        assert.calledWith(submitToCallDiagnosticsSpy, {
+          event: {
+            canProceed: true,
+            eventData: {
+              webClientDomain: 'whatever',
+            },
+            identifiers: {
+              correlationId: 'correlationId3',
+              sessionCorrelationId: 'sessionCorrelationId3',
+              deviceId: 'deviceUrl',
+              locusId: 'url',
+              locusStartTime: 'lastActive',
+              locusUrl: 'locus/url',
+              mediaAgentAlias: 'alias',
+              mediaAgentGroupId: '1',
+              orgId: 'orgId',
+              userId: 'userId',
+            },
+            loginType: 'login-ci',
+            name: 'client.alert.displayed',
+            userType: 'host',
+            isConvergedArchitectureEnabled: undefined,
+            webexSubServiceType: undefined,
+          },
+          eventId: 'my-fake-id',
+          origin: {
+            origin: 'fake-origin',
+          },
+          originTime: {
+            sent: 'not_defined_yet',
+            triggered: now.toISOString(),
+          },
+          senderCountryCode: 'UK',
+          version: 1,
+        });
+        assert.calledWith(validatorSpy, {
+          type: 'ce',
+          event: {
+            event: {
+              canProceed: true,
+              eventData: {
+                webClientDomain: 'whatever',
+              },
+              identifiers: {
+                correlationId: 'correlationId3',
+                sessionCorrelationId: 'sessionCorrelationId3',
                 deviceId: 'deviceUrl',
                 locusId: 'url',
                 locusStartTime: 'lastActive',
@@ -819,6 +1014,9 @@ describe('internal-plugin-metrics', () => {
         const getIdentifiersSpy = sinon.spy(cd, 'getIdentifiers');
         const getSubServiceTypeSpy = sinon.spy(cd, 'getSubServiceType');
         const validatorSpy = sinon.spy(cd, 'validator');
+        sinon.stub(window.navigator, 'userAgent').get(() => userAgent);
+        sinon.stub(bowser, 'getParser').returns(userAgent);
+
         const options = {
           meetingId: fakeMeeting.id,
           mediaConnections: [{mediaAgentAlias: 'alias', mediaAgentGroupId: '1'}],
@@ -847,7 +1045,7 @@ describe('internal-plugin-metrics', () => {
         assert.deepEqual(webexLoggerLogCalls[2].args, [
           'call-diagnostic-events -> ',
           'CallDiagnosticMetrics: @createClientEventObjectInMeeting => collected browser data',
-          '{"error":"unable to access window.navigator.userAgent"}',
+          `${JSON.stringify(userAgent)}`,
         ]);
 
         assert.deepEqual(webexLoggerLogCalls[3].args, [
@@ -1052,7 +1250,6 @@ describe('internal-plugin-metrics', () => {
             },
             identifiers: {
               correlationId: 'correlationId2',
-              sessionCorrelationId: undefined,
               deviceId: 'deviceUrl',
               locusId: 'url',
               locusStartTime: 'lastActive',
@@ -1161,7 +1358,6 @@ describe('internal-plugin-metrics', () => {
             },
             identifiers: {
               correlationId: 'correlationId',
-              sessionCorrelationId: undefined,
               webexConferenceIdStr: 'webexConferenceIdStr1',
               globalMeetingId: 'globalMeetingId1',
               deviceId: 'deviceUrl',
@@ -1240,7 +1436,6 @@ describe('internal-plugin-metrics', () => {
             },
             identifiers: {
               correlationId: 'correlationId',
-              sessionCorrelationId: undefined,
               deviceId: 'deviceUrl',
               locusId: 'url',
               locusStartTime: 'lastActive',
@@ -1316,7 +1511,6 @@ describe('internal-plugin-metrics', () => {
             },
             identifiers: {
               correlationId: 'correlationId',
-              sessionCorrelationId: 'unknown',
               deviceId: 'deviceUrl',
               locusUrl: 'locus-url',
               orgId: 'orgId',
@@ -1390,7 +1584,6 @@ describe('internal-plugin-metrics', () => {
             },
             identifiers: {
               correlationId: 'correlationId',
-              sessionCorrelationId: 'unknown',
               deviceId: 'deviceUrl',
               locusUrl: 'locus-url',
               orgId: 'orgId',
@@ -1470,7 +1663,6 @@ describe('internal-plugin-metrics', () => {
             },
             identifiers: {
               correlationId: 'correlationId',
-              sessionCorrelationId: undefined,
               deviceId: 'deviceUrl',
               locusId: 'url',
               locusStartTime: 'lastActive',
@@ -1603,7 +1795,6 @@ describe('internal-plugin-metrics', () => {
             canProceed: true,
             identifiers: {
               correlationId: 'correlationId',
-              sessionCorrelationId: undefined,
               webexConferenceIdStr: 'webexConferenceIdStr1',
               globalMeetingId: 'globalMeetingId1',
               userId: 'userId',
@@ -1643,7 +1834,6 @@ describe('internal-plugin-metrics', () => {
               canProceed: true,
               identifiers: {
                 correlationId: 'correlationId',
-                sessionCorrelationId: undefined,
                 webexConferenceIdStr: 'webexConferenceIdStr1',
                 globalMeetingId: 'globalMeetingId1',
                 userId: 'userId',
@@ -1689,7 +1879,6 @@ describe('internal-plugin-metrics', () => {
               locusUrl: 'locus/url',
               locusId: 'url',
               locusStartTime: 'lastActive',
-              sessionCorrelationId: undefined,
             },
             eventData: {webClientDomain: 'whatever'},
             intervals: [{}],
@@ -2477,7 +2666,6 @@ describe('internal-plugin-metrics', () => {
                       locusUrl: 'locus/url',
                       orgId: 'orgId',
                       userId: 'userId',
-                      sessionCorrelationId: undefined,
                     },
                     loginType: 'login-ci',
                     name: 'client.exit.app',
@@ -2585,11 +2773,11 @@ describe('internal-plugin-metrics', () => {
       // The method is called in beforeEach itself. We are just testing it here
       it('sets the received deviceInfo to call-diagnostics', () => {
         const webexLoggerLogCalls = webex.logger.log.getCalls();
-        const device = { userId: 'userId', url: 'deviceUrl', orgId: 'orgId' };
+        const device = {userId: 'userId', url: 'deviceUrl', orgId: 'orgId'};
 
         assert.deepEqual(webexLoggerLogCalls[0].args, [
           'CallDiagnosticMetrics: @setDeviceInfo called',
-          device
+          device,
         ]);
 
         assert.deepEqual(cd.device, device);

package/test/unit/spec/rtcMetrics/index.ts

@@ -0,0 +1,155 @@
+import 'jsdom-global/register';
+import RtcMetrics from '../../../../src/rtcMetrics';
+import MockWebex from '@webex/test-helper-mock-webex';
+import {assert} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+import RTC_METRICS from '../../../../src/rtcMetrics/constants';
+
+const FAKE_METRICS_ITEM = {payload: ['{"type":"string","value":"fake-metrics","id":""}']};
+const FAILURE_METRICS_ITEM = {
+  name: "onconnectionstatechange",
+  payload: ['{"type":"string","value":"failed","id":""}'],
+  timestamp: 1707929986667
+};
+
+const STATS_WITH_IP = '{"id":"RTCIceCandidate_/kQs0ZNU","type":"remote-candidate","transportId":"RTCTransport_0_1","isRemote":true,"ip":"11.22.111.255","address":"11.22.111.255","port":5004,"protocol":"udp","candidateType":"host","priority":2130706431}';
+const STATS_WITH_IP_RESULT = '{"id":"RTCIceCandidate_/kQs0ZNU","type":"remote-candidate","transportId":"RTCTransport_0_1","isRemote":true,"ip":"11.22.111.240","address":"11.22.111.240","port":5004,"protocol":"udp","candidateType":"host","priority":2130706431}';
+
+describe('RtcMetrics', () => {
+  let metrics: RtcMetrics;
+  let webex: MockWebex;
+  let clock;
+  let anonymizeIpSpy;
+
+  const sandbox = sinon.createSandbox();
+
+  beforeEach(() => {
+    clock = sinon.useFakeTimers();
+    window.setInterval = setInterval;
+    webex = new MockWebex();
+    metrics = new RtcMetrics(webex, 'mock-meeting-id', 'mock-correlation-id');
+    anonymizeIpSpy = sandbox.spy(metrics, 'anonymizeIp');
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  it('sendMetrics should send a webex request', () => {
+    assert.notCalled(webex.request);
+
+    metrics.addMetrics(FAKE_METRICS_ITEM);
+    (metrics as any).sendMetrics();
+
+    assert.callCount(webex.request, 1);
+    assert.calledWithMatch(webex.request, sinon.match.has('headers', {
+      type: 'webrtcMedia',
+      appId: RTC_METRICS.APP_ID,
+    }));
+    assert.calledWithMatch(webex.request, sinon.match.hasNested('body.metrics[0].data[0].payload', FAKE_METRICS_ITEM.payload));
+    assert.calledWithMatch(webex.request, sinon.match.hasNested('body.metrics[0].meetingId', 'mock-meeting-id'));
+    assert.calledWithMatch(webex.request, sinon.match.hasNested('body.metrics[0].correlationId', 'mock-correlation-id'));
+  });
+
+  it('should have a defined sendMetricsInQueue function which is public', () => {
+    assert.isDefined(metrics.sendMetricsInQueue);
+    assert.isFunction(metrics.sendMetricsInQueue);
+  });
+
+  it('should send metrics requests over time', () => {
+    assert.notCalled(webex.request);
+
+    metrics.addMetrics(FAKE_METRICS_ITEM);
+    assert.deepEqual(metrics.metricsQueue, [FAKE_METRICS_ITEM]);
+    clock.tick(60 * 1000);
+
+    assert.callCount(webex.request, 1);
+  });
+
+  it('should not send requests with no items in the queue', () => {
+    clock.tick(60 * 1000);
+    assert.notCalled(webex.request);
+  });
+
+  it('sendMetricsInQueue should send metrics if any exist in the queue', () => {
+    assert.notCalled(webex.request);
+
+    metrics.addMetrics(FAKE_METRICS_ITEM);
+    (metrics as any).sendMetricsInQueue();
+
+    assert.callCount(webex.request, 1);
+  });
+
+  it('should clear out metrics on close', () => {
+    assert.notCalled(webex.request);
+
+    metrics.addMetrics(FAKE_METRICS_ITEM);
+    metrics.closeMetrics();
+
+    assert.callCount(webex.request, 1);
+  });
+
+  it('should clear out metrics on failure', () => {
+    assert.notCalled(webex.request);
+
+    metrics.addMetrics(FAILURE_METRICS_ITEM);
+
+    assert.callCount(webex.request, 1);
+  });
+
+  it('should have the same connectionId on success', () => {
+    const originalId = metrics.connectionId;
+
+    metrics.addMetrics(FAKE_METRICS_ITEM);
+
+    assert.strictEqual(originalId, metrics.connectionId);
+  });
+
+  it('should have a new connectionId on failure', () => {
+    const originalId = metrics.connectionId;
+
+    metrics.addMetrics(FAILURE_METRICS_ITEM);
+
+    assert.notEqual(originalId, metrics.connectionId);
+  });
+
+  it('should anonymize IP addresses', () => {
+    assert.strictEqual(metrics.anonymizeIp(STATS_WITH_IP), STATS_WITH_IP_RESULT);
+  });
+
+  it('should call anonymizeIp', () => {
+    metrics.addMetrics({ name: 'stats-report', payload: [STATS_WITH_IP] });
+    assert.calledOnce(anonymizeIpSpy);
+  })
+
+  it('should send metrics on first stats-report', () => {
+    assert.callCount(webex.request, 0);
+
+    metrics.addMetrics(FAKE_METRICS_ITEM);
+    assert.callCount(webex.request, 0);
+
+    // first stats-report should trigger a call to webex.request
+    metrics.addMetrics({ name: 'stats-report', payload: [STATS_WITH_IP] });
+    assert.callCount(webex.request, 1);
+  });
+
+  it('should send metrics on first stats-report after a new connection', () => {
+    assert.callCount(webex.request, 0);
+
+    // first stats-report should trigger a call to webex.request
+    metrics.addMetrics({ name: 'stats-report', payload: [STATS_WITH_IP] });
+    assert.callCount(webex.request, 1);
+
+    // subsequent stats-report doesn't trigger it
+    metrics.addMetrics({ name: 'stats-report', payload: [STATS_WITH_IP] });
+    assert.callCount(webex.request, 1);
+
+    // now, simulate a failure - that triggers a new connection and upload of the metrics
+    metrics.addMetrics(FAILURE_METRICS_ITEM);
+    assert.callCount(webex.request, 2);
+
+    // and another stats-report should trigger another upload of the metrics
+    metrics.addMetrics({ name: 'stats-report', payload: [STATS_WITH_IP] });
+    assert.callCount(webex.request, 3);
+  });
+});