@webex/internal-plugin-metrics 3.12.0-task-refactor.1 → 3.12.0-webex-services-ready.2

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

@@ -10,6 +10,7 @@ import {
   ICE_AND_REACHABILITY_FAILED_CLIENT_CODE,
   ICE_FAILED_WITH_TURN_TLS_CLIENT_CODE,
   MISSING_ROAP_ANSWER_CLIENT_CODE,
+  BROWSER_MEDIA_ERROR_NAME_TO_CLIENT_ERROR_CODES_MAP,
 } from '../../../../src/call-diagnostic/config';
 import Logger from '@webex/plugin-logger';
 
@@ -26,6 +27,7 @@ const {
   isUnauthorizedError,
   generateClientErrorCodeForIceFailure,
   isSdpOfferCreationError,
+  isWebrtcApiNotAvailableError,
 } = CallDiagnosticUtils;
 
 describe('internal-plugin-metrics', () => {
@@ -205,6 +207,29 @@ describe('internal-plugin-metrics', () => {
     });
   });
 
+  describe('isWebrtcApiNotAvailableError', () => {
+    type TestWebrtcApiNotAvailableError = {
+      code: number;
+      message: string;
+      name: string;
+    };
+
+    const error: TestWebrtcApiNotAvailableError = {
+      code: 30007,
+      name: 'WebrtcApiNotAvailableError',
+      message: 'RTCPeerConnection API is not available in this environment',
+    };
+
+    [
+      ['WebrtcApiNotAvailableError', error, true],
+      ['generic error', new Error('this is an error'), false],
+    ].forEach(([errorType, rawError, expected]) => {
+      it(`for ${errorType} rawError returns the correct result`, () => {
+        assert.strictEqual(isWebrtcApiNotAvailableError(rawError), expected);
+      });
+    });
+  });
+
   describe('isBrowserMediaErrorName', () => {
     [
       ['PermissionDeniedError', true],
@@ -286,7 +311,7 @@ describe('internal-plugin-metrics', () => {
           origin: {
             buildType: 'prod',
             networkType: 'unknown',
-            upgradeChannel: expectedUpgradeChannel
+            upgradeChannel: expectedUpgradeChannel,
           },
           event: {name: eventName, ...expectedEvent},
         },
@@ -368,7 +393,7 @@ describe('internal-plugin-metrics', () => {
             totalJmt: undefined,
             clientJmt: undefined,
             downloadTime: undefined,
-            clickToInterstitialWithUserDelay:   undefined,
+            clickToInterstitialWithUserDelay: undefined,
             totalJMTWithUserDelay: undefined,
           },
         },
@@ -405,7 +430,6 @@ describe('internal-plugin-metrics', () => {
             totalMediaJMT: undefined,
             interstitialToMediaOKJMT: undefined,
             callInitMediaEngineReady: undefined,
-            stayLobbyTime: undefined,
             totalMediaJMTWithUserDelay: undefined,
             totalJMTWithUserDelay: undefined,
           },
@@ -422,12 +446,47 @@ describe('internal-plugin-metrics', () => {
           },
         },
       ],
+      [
+        'client.lobby.exited',
+        {
+          joinTimes: {
+            stayLobbyTime: undefined,
+          },
+        },
+      ],
     ].forEach(([eventName, expectedEvent]) => {
       it(`returns expected result for ${eventName}`, () => {
         check(eventName as string, expectedEvent, 'gold');
       });
     });
 
+    it('logs a Milestone entry when event name is present', () => {
+      const logSpy = sinon.spy(webex.logger, 'log');
+      const eventName = 'client.call.initiated';
+      const eventPayload = {event: {name: eventName}};
+
+      prepareDiagnosticMetricItem(webex, {eventPayload, type: ['diagnostic-event']});
+
+      assert.isTrue(
+        logSpy.calledWith('Milestone,CallDiagnostic', eventName),
+        'expected logger.log to be called with Milestone,CallDiagnostic and the event name'
+      );
+      sinon.restore();
+    });
+
+    it('does not log a Milestone entry when event name is absent', () => {
+      const logSpy = sinon.spy(webex.logger, 'log');
+      const eventPayload = {event: {}};
+
+      prepareDiagnosticMetricItem(webex, {eventPayload, type: ['diagnostic-event']});
+
+      assert.isFalse(
+        logSpy.calledWith('Milestone,CallDiagnostic', sinon.match.any),
+        'expected logger.log not to be called with Milestone,CallDiagnostic when event name is absent'
+      );
+      sinon.restore();
+    });
+
     it('sets buildType and upgradeChannel correctly', () => {
       const item: any = {
         eventPayload: {
@@ -685,4 +744,34 @@ describe('internal-plugin-metrics', () => {
       });
     });
   });
+
+  describe('isBrowserMediaError', () => {
+    it('should return true if error name is in BROWSER_MEDIA_ERROR_NAME_TO_CLIENT_ERROR_CODES_MAP', () => {
+      // Use a known browser media error name from the config map
+      const errorName = Object.keys(BROWSER_MEDIA_ERROR_NAME_TO_CLIENT_ERROR_CODES_MAP)[0];
+      const error = {name: errorName};
+      assert.isTrue(CallDiagnosticUtils.isBrowserMediaError(error));
+    });
+
+    it('should return false if error name is not in BROWSER_MEDIA_ERROR_NAME_TO_CLIENT_ERROR_CODES_MAP', () => {
+      const error = {name: 'SomeOtherError'};
+      assert.isFalse(CallDiagnosticUtils.isBrowserMediaError(error));
+    });
+  });
+
+  describe('getBrowserMediaErrorCode', () => {
+    it('should return correct error code for known error name', () => {
+      const errorName = Object.keys(BROWSER_MEDIA_ERROR_NAME_TO_CLIENT_ERROR_CODES_MAP)[0];
+      const error = {name: errorName};
+      assert.strictEqual(
+        CallDiagnosticUtils.getBrowserMediaErrorCode(error),
+        BROWSER_MEDIA_ERROR_NAME_TO_CLIENT_ERROR_CODES_MAP[errorName]
+      );
+    });
+
+    it('should return undefined for unknown error name', () => {
+      const error = {name: 'UnknownError'};
+      assert.isUndefined(CallDiagnosticUtils.getBrowserMediaErrorCode(error));
+    });
+  });
 });

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

@@ -64,45 +64,37 @@ describe('internal-plugin-metrics', () => {
         //@ts-ignore
         assert.calledOnce(webex.request);
 
-        // matching because the request includes a symbol key: value pair and sinon cannot handle to compare it..
-        assert.match(webexRequestArgs, {
-          //@ts-ignore
-          body: {
-            metrics: [
-              {
-                eventPayload: {
-                  event: {
-                    joinTimes: {
-                      meetingInfoReqResp: undefined,
-                      clickToInterstitial: undefined,
-                      refreshCaptchaServiceReqResp: undefined,
-                      downloadIntelligenceModelsReqResp: undefined,
-                      clickToInterstitialWithUserDelay: undefined,
-                    },
-                    name: 'client.interstitial-window.launched',
-                  },
-                  origin: {
-                    buildType: 'test',
-                    networkType: 'unknown',
-                    upgradeChannel: 'test',
-                  },
-                  originTime: {
-                    sent: dateAfterBatcherWait.toISOString(),
-                  },
-                },
-                type: ['diagnostic-event'],
-              },
-            ],
+        assert.deepEqual(webexRequestArgs.headers, {
+          authorization: false,
+          'x-prelogin-userid': preLoginId,
+        });
+        assert.equal(webexRequestArgs.method, 'POST');
+        assert.equal(webexRequestArgs.resource, 'clientmetrics-prelogin');
+        assert.equal(webexRequestArgs.service, 'metrics');
+        assert.equal(webexRequestArgs.waitForServiceTimeout, 30);
+
+        assert.deepEqual(webexRequestArgs.body.metrics[0].eventPayload, {
+          event: {
+            joinTimes: {
+              meetingInfoReqResp: undefined,
+              clickToInterstitial: undefined,
+              refreshCaptchaServiceReqResp: undefined,
+              downloadIntelligenceModelsReqResp: undefined,
+              clickToInterstitialWithUserDelay: undefined,
+            },
+            name: 'client.interstitial-window.launched',
           },
-          headers: {
-            authorization: false,
-            'x-prelogin-userid': preLoginId,
+          origin: {
+            buildType: 'test',
+            networkType: 'unknown',
+            upgradeChannel: 'test',
+          },
+          originTime: {
+            sent: dateAfterBatcherWait.toISOString(),
           },
-          method: 'POST',
-          resource: 'clientmetrics-prelogin',
-          service: 'metrics',
-          waitForServiceTimeout: 30,
         });
+        assert.deepEqual(webexRequestArgs.body.metrics[0].type, ['diagnostic-event']);
+        assert.equal(webexRequestArgs.body.metrics[0].markTelemetryOptOutOnResponse, true);
         assert.lengthOf(
           webex.internal.newMetrics.callDiagnosticMetrics.preLoginMetricsBatcher.queue,
           0
@@ -320,5 +312,167 @@ describe('internal-plugin-metrics', () => {
         );
       });
     });
+
+    describe('#submitHttpRequest', () => {
+      it('calls webex.request with the correct parameters and then it calls handleHttpResponseStatus on success', async () => {
+        const payload = [
+          {
+            eventPayload: {event: 'my.event'},
+            type: ['diagnostic-event'],
+          },
+        ];
+
+        webex.internal.newMetrics.callDiagnosticMetrics.preLoginMetricsBatcher.savePreLoginId(
+          preLoginId
+        );
+        webex.request = sinon.stub().resolves({statusCode: 200});
+
+        const handleHttpResponseStatusSpy = sinon.spy(
+          webex.internal.newMetrics.callDiagnosticMetrics.preLoginMetricsBatcher,
+          'handleHttpResponseStatus'
+        );
+
+        const promise =
+          webex.internal.newMetrics.callDiagnosticMetrics.preLoginMetricsBatcher.submitHttpRequest(
+            payload
+          );
+
+        assert.deepEqual(handleHttpResponseStatusSpy.getCalls().length, 0);
+
+        await flushPromises();
+
+        clock.tick(config.metrics.batcherWait);
+
+        await promise;
+
+        const webexRequestArgs = webex.request.args[0][0];
+
+        assert.match(webexRequestArgs, {
+          //@ts-ignore
+          body: {
+            metrics: payload,
+          },
+          headers: {
+            authorization: false,
+            'x-prelogin-userid': preLoginId,
+          },
+          method: 'POST',
+          resource: 'clientmetrics-prelogin',
+          service: 'metrics',
+          waitForServiceTimeout: 30,
+        });
+
+        assert.deepEqual(handleHttpResponseStatusSpy.getCalls().length, 1);
+
+        assert.deepEqual(handleHttpResponseStatusSpy.args[0][0], 200);
+        assert.deepEqual(handleHttpResponseStatusSpy.args[0][1], payload);
+      });
+
+      it('it calls handleHttpResponseStatus on failure', async () => {
+        const payload = [
+          {
+            eventPayload: {event: 'my.event'},
+            type: ['diagnostic-event'],
+          },
+        ];
+
+        webex.internal.newMetrics.callDiagnosticMetrics.preLoginMetricsBatcher.savePreLoginId(
+          preLoginId
+        );
+        webex.request = sinon.stub().rejects({statusCode: 503});
+
+        const handleHttpResponseStatusSpy = sinon.spy(
+          webex.internal.newMetrics.callDiagnosticMetrics.preLoginMetricsBatcher,
+          'handleHttpResponseStatus'
+        );
+
+        const promise =
+          webex.internal.newMetrics.callDiagnosticMetrics.preLoginMetricsBatcher.submitHttpRequest(
+            payload
+          );
+
+        assert.deepEqual(handleHttpResponseStatusSpy.getCalls().length, 0);
+
+        await flushPromises();
+
+        clock.tick(config.metrics.batcherWait);
+
+        let error;
+
+        try {
+          await promise;
+        } catch (err) {
+          error = err;
+        }
+
+        assert.deepEqual(error.statusCode, 503);
+
+        assert.deepEqual(handleHttpResponseStatusSpy.getCalls().length, 1);
+
+        assert.deepEqual(handleHttpResponseStatusSpy.args[0][0], 503);
+        assert.deepEqual(handleHttpResponseStatusSpy.args[0][1], payload);
+      });
+    })
+
+    describe('#handleHttpResponseStatus', () => {
+      let setIsTelemetryOptOutAutomaticStub;
+
+      beforeEach(() => {
+        setIsTelemetryOptOutAutomaticStub = sinon.stub(
+          webex.internal.newMetrics.callDiagnosticMetrics,
+          'setIsTelemetryOptOutAutomatic'
+        );
+      });
+
+      [201, 400, 503, undefined].forEach((statusCode) => {
+        it(`does not call setIsTelemetryOptOutAutomatic when shouldMark is true and statusCode is ${statusCode}`, () => {
+          webex.internal.newMetrics.callDiagnosticMetrics.preLoginMetricsBatcher.handleHttpResponseStatus(
+            statusCode,
+            [{markTelemetryOptOutOnResponse: true}]
+          );
+
+          assert.notCalled(setIsTelemetryOptOutAutomaticStub);
+        });
+      });
+
+      it('calls setIsTelemetryOptOutAutomatic(true) when statusCode is 200 and markTelemetryOptOutOnResponse is true', () => {
+        webex.internal.newMetrics.callDiagnosticMetrics.preLoginMetricsBatcher.handleHttpResponseStatus(
+          200,
+          [{markTelemetryOptOutOnResponse: true}]
+        );
+
+        assert.calledOnce(setIsTelemetryOptOutAutomaticStub);
+        assert.calledWithExactly(setIsTelemetryOptOutAutomaticStub, true);
+      });
+
+      [200, 201, 400, 503, undefined].forEach((statusCode) => {
+        it(`does not call setIsTelemetryOptOutAutomatic when shouldMark is false (statusCode: ${statusCode})`, () => {
+          webex.internal.newMetrics.callDiagnosticMetrics.preLoginMetricsBatcher.handleHttpResponseStatus(
+            statusCode,
+            [{markTelemetryOptOutOnResponse: false}]
+          );
+
+          assert.notCalled(setIsTelemetryOptOutAutomaticStub);
+        });
+      });
+
+      it('does not call setIsTelemetryOptOutAutomatic when payload is empty', () => {
+        webex.internal.newMetrics.callDiagnosticMetrics.preLoginMetricsBatcher.handleHttpResponseStatus(
+          200,
+          []
+        );
+
+        assert.notCalled(setIsTelemetryOptOutAutomaticStub);
+      });
+
+      it('does not call setIsTelemetryOptOutAutomatic when payload is not an array', () => {
+        webex.internal.newMetrics.callDiagnosticMetrics.preLoginMetricsBatcher.handleHttpResponseStatus(
+          200,
+          null
+        );
+
+        assert.notCalled(setIsTelemetryOptOutAutomaticStub);
+      });
+    });
   });
 });

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

@@ -0,0 +1,132 @@
+import PreLoginMetricsBatcher from '../../../src/prelogin-metrics-batcher';
+import {PreLoginMetrics} from '@webex/internal-plugin-metrics';
+import {assert} from '@webex/test-helper-chai';
+import MockWebex from '@webex/test-helper-mock-webex';
+import sinon from 'sinon';
+
+describe('internal-plugin-metrics', () => {
+  const mockedWebex: MockWebex = new MockWebex();
+  const fakedPreLoginMetricsBatcher: typeof PreLoginMetricsBatcher = new PreLoginMetricsBatcher({}, {parent: mockedWebex});
+
+  describe('prelogin-metrics', () => {
+    afterEach(() => {
+      sinon.restore();
+    });
+
+    it('Should send metrics to preloginMetricsBatcher', async () => {
+      const testEvent = 'test';
+      const testId = 'abc123';
+      const preLoginMetrics = new PreLoginMetrics(fakedPreLoginMetricsBatcher, {}, {parent: mockedWebex});
+
+      sinon.stub(fakedPreLoginMetricsBatcher, 'savePreLoginId');
+      const requestSpy = sinon.stub(fakedPreLoginMetricsBatcher, 'request');
+
+      await preLoginMetrics.submitPreLoginEvent({name: testEvent, preLoginId: testId, payload: {}});
+
+      assert.calledOnceWithMatch(requestSpy, {
+        type: ['business'],
+        eventPayload: {metricName: testEvent, value: {preLoginId: testId}},
+      });
+    });
+
+    it('Should send metadata to preloginMetricsBatcher', async () => {
+      const testEvent = 'test';
+      const testId = 'abc123';
+      const testMetadata = { 'testKey': 'test-value' };
+      const preLoginMetrics = new PreLoginMetrics(fakedPreLoginMetricsBatcher, {}, {parent: mockedWebex});
+
+      sinon.stub(fakedPreLoginMetricsBatcher, 'savePreLoginId');
+      const requestSpy = sinon.stub(fakedPreLoginMetricsBatcher, 'request');
+
+      await preLoginMetrics.submitPreLoginEvent({name: testEvent, preLoginId: testId, payload: {}, metadata: testMetadata});
+
+      assert.calledOnceWithMatch(requestSpy, {
+        type: ['business'],
+        eventPayload: {metricName: testEvent, value: {preLoginId: testId, ...testMetadata}},
+      });
+    });
+
+    it('Should send payload to preloginMetricsBatcher', async () => {
+      const testEvent = 'test';
+      const testId = 'abc123';
+      const testPayload = { 'testKey': 'test-value' };
+      const preLoginMetrics = new PreLoginMetrics(fakedPreLoginMetricsBatcher, {}, {parent: mockedWebex});
+
+      sinon.stub(fakedPreLoginMetricsBatcher, 'savePreLoginId');
+      const requestSpy = sinon.stub(fakedPreLoginMetricsBatcher, 'request');
+
+      await preLoginMetrics.submitPreLoginEvent({name: testEvent, preLoginId: testId, payload: testPayload});
+
+      assert.calledOnceWithMatch(requestSpy, {
+        type: ['business'],
+        eventPayload: {metricName: testEvent, value: {preLoginId: testId, ...testPayload}},
+      });
+    });
+
+    it('Should fill appType if not defined', async () => {
+      const testEvent = 'test';
+      const preLoginMetrics = new PreLoginMetrics(fakedPreLoginMetricsBatcher, {}, {parent: mockedWebex});
+
+      sinon.stub(fakedPreLoginMetricsBatcher, 'savePreLoginId');
+      const requestSpy = sinon.stub(fakedPreLoginMetricsBatcher, 'request');
+
+      await preLoginMetrics.submitPreLoginEvent({name: testEvent, preLoginId: 'abc123', payload: {}});
+
+      assert.calledOnceWithMatch(requestSpy, {
+        type: ['business'],
+        eventPayload: {metricName: testEvent, value: {appType: 'Web Client'}},
+      });
+    });
+
+    it('Should add browser details', async () => {
+      const testEvent = 'test';
+      const testBrowserDetails = { browser: 'Firefox', domain: 'test.example.com' };
+      const preLoginMetrics = new PreLoginMetrics(fakedPreLoginMetricsBatcher, {}, {parent: mockedWebex});
+
+      sinon.stub(preLoginMetrics, 'getBrowserDetails').returns(testBrowserDetails);
+      sinon.stub(fakedPreLoginMetricsBatcher, 'savePreLoginId');
+      const requestSpy = sinon.stub(fakedPreLoginMetricsBatcher, 'request');
+
+      await preLoginMetrics.submitPreLoginEvent({name: testEvent, preLoginId: 'abc123', payload: {}});
+
+      assert.calledOnceWithMatch(requestSpy, {
+        type: ['business'],
+        eventPayload: {browserDetails: testBrowserDetails, metricName: testEvent},
+      });
+    });
+
+    it('Should add context', async () => {
+      const testEvent = 'test';
+      const testContext = { device: { id: 'abc123' }};
+      const preLoginMetrics = new PreLoginMetrics(fakedPreLoginMetricsBatcher, {}, {parent: mockedWebex});
+
+      sinon.stub(preLoginMetrics, 'getContext').returns(testContext);
+      sinon.stub(fakedPreLoginMetricsBatcher, 'savePreLoginId');
+      const requestSpy = sinon.stub(fakedPreLoginMetricsBatcher, 'request');
+
+      await preLoginMetrics.submitPreLoginEvent({name: testEvent, preLoginId: 'abc123', payload: {}});
+
+      assert.calledOnceWithMatch(requestSpy, {
+        type: ['business'],
+        eventPayload: {context: testContext, metricName: testEvent},
+      });
+    });
+
+    it('Should add timestamp', async () => {
+      const testEvent = 'test';
+      const testTime = 1234;
+      const preLoginMetrics = new PreLoginMetrics(fakedPreLoginMetricsBatcher, {}, {parent: mockedWebex});
+
+      sinon.useFakeTimers(testTime);
+      sinon.stub(fakedPreLoginMetricsBatcher, 'savePreLoginId');
+      const requestSpy = sinon.stub(fakedPreLoginMetricsBatcher, 'request');
+
+      await preLoginMetrics.submitPreLoginEvent({name: testEvent, preLoginId: 'abc123', payload: {}});
+
+      assert.calledOnceWithMatch(requestSpy, {
+        type: ['business'],
+        eventPayload: {metricName: testEvent, timestamp: testTime},
+      });
+    });
+  });
+});