@webex/internal-plugin-metrics 3.0.0-beta.374 → 3.0.0-beta.376

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

@@ -1,15 +1,16 @@
 import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
 import {WebexHttpError} from '@webex/webex-core';
-
-import CallDiagnosticMetrics from '../../../../src/call-diagnostic/call-diagnostic-metrics';
-import CallDiagnosticLatencies from '../../../../src/call-diagnostic/call-diagnostic-metrics-latencies';
-import * as Utils from '../../../../src/call-diagnostic/call-diagnostic-metrics.util';
-import {BrowserDetection, getBrowserSerial} from '@webex/common';
-import {getOSNameInternal} from '@webex/internal-plugin-metrics';
+import {BrowserDetection} from '@webex/common';
+import {
+  CallDiagnosticLatencies,
+  CallDiagnosticMetrics,
+  getOSNameInternal,
+  CallDiagnosticUtils,
+  config,
+} from '@webex/internal-plugin-metrics';
 import uuid from 'uuid';
 import {omit} from 'lodash';
-import CONFIG from '../../../../src/config';
 
 //@ts-ignore
 global.window = {location: {hostname: 'whatever'}};
@@ -67,11 +68,9 @@ describe('internal-plugin-metrics', () => {
           },
           metrics: {
             submitClientMetrics: sinon.stub(),
-            config: {...CONFIG.metrics},
-          },
-          newMetrics: {
-            postPreLoginMetric: sinon.stub(),
+            config: {...config.metrics},
           },
+          newMetrics: {},
           device: {
             userId: 'userId',
             url: 'deviceUrl',
@@ -128,7 +127,7 @@ describe('internal-plugin-metrics', () => {
 
     describe('#getOrigin', () => {
       it('should build origin correctly', () => {
-        sinon.stub(Utils, 'anonymizeIPAddress').returns('1.1.1.1');
+        sinon.stub(CallDiagnosticUtils, 'anonymizeIPAddress').returns('1.1.1.1');
         //@ts-ignore
         const res = cd.getOrigin(
           {subClientType: 'WEB_APP', clientType: 'TEAMS_CLIENT'},
@@ -155,7 +154,7 @@ describe('internal-plugin-metrics', () => {
       });
 
       it('should build origin correctly with newEnvironment and createLaunchMethod', () => {
-        sinon.stub(Utils, 'anonymizeIPAddress').returns('1.1.1.1');
+        sinon.stub(CallDiagnosticUtils, 'anonymizeIPAddress').returns('1.1.1.1');
 
         //@ts-ignore
         const res = cd.getOrigin(
@@ -190,7 +189,7 @@ describe('internal-plugin-metrics', () => {
       });
 
       it('should build origin correctly and environment can be passed in options', () => {
-        sinon.stub(Utils, 'anonymizeIPAddress').returns('1.1.1.1');
+        sinon.stub(CallDiagnosticUtils, 'anonymizeIPAddress').returns('1.1.1.1');
 
         //@ts-ignore
         const res = cd.getOrigin(
@@ -224,7 +223,7 @@ describe('internal-plugin-metrics', () => {
       });
 
       it('should build origin correctly with no meeting', () => {
-        sinon.stub(Utils, 'anonymizeIPAddress').returns('1.1.1.1');
+        sinon.stub(CallDiagnosticUtils, 'anonymizeIPAddress').returns('1.1.1.1');
 
         //@ts-ignore
         const res = cd.getOrigin();
@@ -498,7 +497,7 @@ 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(Utils, 'clearEmptyKeysRecursively');
+      const clearEmptyKeysRecursivelyStub = sinon.stub(CallDiagnosticUtils, 'clearEmptyKeysRecursively');
 
       const res = cd.prepareDiagnosticEvent(
         {
@@ -854,32 +853,27 @@ describe('internal-plugin-metrics', () => {
         );
         assert.notCalled(submitToCallDiagnosticsSpy);
         assert.calledWith(submitToCallDiagnosticsPreLoginSpy, {
-          event: {
-            canProceed: true,
-            eventData: {
-              webClientDomain: 'whatever',
-            },
-            identifiers: {
-              correlationId: 'correlationId',
-              webexConferenceIdStr: 'webexConferenceIdStr1',
-              globalMeetingId: 'globalMeetingId1',
-              deviceId: 'deviceUrl',
-              locusUrl: 'locus-url',
-              orgId: 'orgId',
-              userId: 'myPreLoginId',
+            eventId: 'my-fake-id',
+            version: 1,
+            origin: { origin: 'fake-origin' },
+            originTime: { triggered: now.toISOString(), sent: 'not_defined_yet' },
+            senderCountryCode: 'UK',
+            event: {
+              name: 'client.alert.displayed',
+              canProceed: true,
+              identifiers: {
+                correlationId: 'correlationId',
+                userId: 'myPreLoginId',
+                deviceId: 'deviceUrl',
+                orgId: 'orgId',
+                locusUrl: 'locus-url',
+                webexConferenceIdStr: 'webexConferenceIdStr1',
+                globalMeetingId: 'globalMeetingId1'
+              },
+              eventData: { webClientDomain: 'whatever' },
+              loginType: 'login-ci'
             },
-            loginType: 'login-ci',
-            name: 'client.alert.displayed',
-          },
-          eventId: 'my-fake-id',
-          origin: {buildType: 'test', networkType: 'unknown', origin: 'fake-origin'},
-          originTime: {
-            triggered: now.toISOString(),
-            sent: now.toISOString(),
-          },
-          senderCountryCode: 'UK',
-          version: 1,
-        });
+        }, options.preLoginId);
       });
 
       it('should use meeting loginType if present and meetingId provided', () => {
@@ -1030,8 +1024,6 @@ describe('internal-plugin-metrics', () => {
           options,
         });
 
-        console.log(submitToCallDiagnosticsSpy.getCalls()[0].args[0].event.errors);
-
         assert.calledWith(submitToCallDiagnosticsSpy, {
           event: {
             canProceed: true,
@@ -1346,14 +1338,16 @@ describe('internal-plugin-metrics', () => {
       });
     });
 
-    it('should send request to call diagnostic batcher', () => {
-      const requestStub = sinon.stub();
-      //@ts-ignore
-      cd.callDiagnosticEventsBatcher = {request: requestStub};
-      //@ts-ignore
-      cd.submitToCallDiagnostics({event: 'test'});
-      assert.calledWith(requestStub, {eventPayload: {event: 'test'}, type: ['diagnostic-event']});
-    });
+    describe("#submitToCallDiagnostics", () => {
+      it('should send request to call diagnostic batcher', () => {
+        const requestStub = sinon.stub();
+        //@ts-ignore
+        cd.callDiagnosticEventsBatcher = {request: requestStub};
+        //@ts-ignore
+        cd.submitToCallDiagnostics({event: 'test'});
+        assert.calledWith(requestStub, {eventPayload: {event: 'test'}, type: ['diagnostic-event']});
+      });
+    })
 
     describe('#submitMQE', () => {
       it('submits the event correctly', () => {
@@ -2083,7 +2077,7 @@ describe('internal-plugin-metrics', () => {
               method: 'POST',
               resource: 'clientmetrics-prelogin',
               service: 'metrics',
-              waitForServiceTimeout: CONFIG.metrics.waitForServiceTimeout,
+              waitForServiceTimeout: config.metrics.waitForServiceTimeout,
               headers: {
                 authorization: false,
                 'x-prelogin-userid': preLoginId,
@@ -2096,7 +2090,7 @@ describe('internal-plugin-metrics', () => {
               resource: 'clientmetrics',
               service: 'metrics',
               headers: {},
-              waitForServiceTimeout: CONFIG.metrics.waitForServiceTimeout,
+              waitForServiceTimeout: config.metrics.waitForServiceTimeout,
             });
           }
 
@@ -2111,51 +2105,20 @@ describe('internal-plugin-metrics', () => {
       });
     });
 
-    describe('#submitToCallDiagnosticsPreLogin', async () => {
-      it('should call webex.request with expected options', async () => {
-        sinon.spy(Utils, 'prepareDiagnosticMetricItem');
-        await cd.submitToCallDiagnosticsPreLogin(
-          {
-            //@ts-ignore
-            event: {name: 'client.alert.displayed', canProceed: true},
-            //@ts-ignore
-            originTime: {triggered: 'now'},
-          },
-          'my-id'
-        );
-
-        assert.calledWith(Utils.prepareDiagnosticMetricItem, webex, {
-          eventPayload: {
-            event: {name: 'client.alert.displayed', canProceed: true},
-            originTime: {triggered: 'now', sent: now.toISOString()},
-            origin: {buildType: 'test', networkType: 'unknown'},
-          },
-          type: ['diagnostic-event'],
-        });
-
-        assert.calledWith(
-          webex.internal.newMetrics.postPreLoginMetric,
-          {
-            eventPayload: {
-              event: {
-                name: 'client.alert.displayed',
-                canProceed: true,
-              },
-              originTime: {
-                sent: now.toISOString(),
-                triggered: 'now',
-              },
-              origin: {
-                buildType: 'test',
-                networkType: 'unknown',
-              },
-            },
-            type: ['diagnostic-event'],
-          },
-          'my-id'
-        );
+    describe("#submitToCallDiagnosticsPreLogin", () => {
+      it('should send request to call diagnostic batcher and saves preLoginId', () => {
+        const requestStub = sinon.stub();
+        //@ts-ignore
+        const preLoginId = '123';
+        //@ts-ignore
+        cd.preLoginMetricsBatcher = {request: requestStub, savePreLoginId: sinon.stub()};
+        //@ts-ignore
+        cd.submitToCallDiagnosticsPreLogin({event: 'test'}, preLoginId);
+        //@ts-ignore
+        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"', () => {

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

@@ -67,7 +67,6 @@ describe('internal-plugin-metrics', () => {
       webex.internal.newMetrics.callDiagnosticMetrics.submitClientEvent = sinon.stub();
       webex.internal.newMetrics.callDiagnosticMetrics.submitMQE = sinon.stub();
       webex.internal.newMetrics.callDiagnosticMetrics.clientMetricsAliasUser = sinon.stub();
-      webex.internal.newMetrics.callDiagnosticMetrics.postPreLoginMetric = sinon.stub();
       webex.internal.newMetrics.callDiagnosticMetrics.buildClientEventFetchRequestOptions =
         sinon.stub();
       webex.setTimingsAndFetch = sinon.stub();
@@ -175,38 +174,6 @@ describe('internal-plugin-metrics', () => {
       });
     });
 
-    describe('#postPreLoginMetric', () => {
-      it('sends the request correctly', async () => {
-        webex.request.resolves({response: 'abc'});
-        await webex.internal.newMetrics.postPreLoginMetric({event: 'test'}, 'my-id');
-        assert.calledWith(webex.request, {
-          method: 'POST',
-          api: 'metrics',
-          resource: 'clientmetrics-prelogin',
-          headers: { 'x-prelogin-userid': 'my-id', authorization: false },
-          body: {metrics: [{event: 'test'}]},
-        });
-        assert.calledWith(
-          webex.logger.log,
-          'NewMetrics: @postPreLoginMetric. Request successful.'
-        );
-      });
-
-      it('handles failed request correctly', async () => {
-        webex.request.rejects(new Error("test error"));
-        sinon.stub(Utils, 'generateCommonErrorMetadata').returns('formattedError')
-        try {
-          await webex.internal.newMetrics.postPreLoginMetric({event: 'test'}, 'my-id');
-        } catch (err) {
-          assert.calledWith(
-            webex.logger.error,
-            'NewMetrics: @postPreLoginMetric. Request failed:',
-            `err: formattedError`
-          );
-        }
-      });
-    })
-
     describe('#buildClientEventFetchRequestOptions', () => {
       it('builds client event fetch options successfully', () => {
         webex.internal.newMetrics.buildClientEventFetchRequestOptions({

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

@@ -0,0 +1,250 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import {assert} from '@webex/test-helper-chai';
+import {config, Utils} from '@webex/internal-plugin-metrics';
+import {CallDiagnosticUtils} from '@webex/internal-plugin-metrics';
+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);
+
+describe('internal-plugin-metrics', () => {
+  describe('PreLoginMetricsBatcher', () => {
+    let webex;
+    let clock;
+    let now;
+
+    const preLoginId = 'my_prelogin_id';
+
+    beforeEach(() => {
+      now = new Date();
+      clock = FakeTimers.install({now});
+
+      //@ts-ignore
+      webex = new MockWebex({
+        children: {
+          newMetrics: NewMetrics,
+        },
+      });
+
+      webex.request = (options) =>
+        Promise.resolve({body: {items: []}, waitForServiceTimeout: 15, options});
+
+      sinon.spy(webex, 'request');
+      webex.emit('ready');
+      webex.config.metrics = config.metrics;
+    });
+
+    afterEach(() => {
+      sinon.restore();
+      clock.uninstall();
+    });
+
+    describe('#request()', () => {
+      it('when the request completes successfully, clears the queue', async () => {
+        const promise =
+          webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnosticsPreLogin(
+            //@ts-ignore
+            {event: {name: 'client.interstitial-window.launched'}},
+            preLoginId
+          );
+        await flushPromises();
+        clock.tick(config.metrics.batcherWait);
+
+        await promise;
+
+        const webexRequestArgs = webex.request.args[0][0];
+
+        const dateAfterBatcherWait = new Date(now.getTime() + config.metrics.batcherWait);
+        //@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, {
+          body: {
+            metrics: [
+              {
+                eventPayload: {
+                  event: {
+                    joinTimes: {
+                      meetingInfoReqResp: undefined,
+                      clickToInterstitial: undefined,
+                    },
+                    name: 'client.interstitial-window.launched',
+                  },
+                  origin: {
+                    buildType: 'test',
+                    networkType: 'unknown',
+                  },
+                  originTime: {
+                    sent: dateAfterBatcherWait.toISOString(),
+                  },
+                },
+                type: ['diagnostic-event'],
+              },
+            ],
+          },
+          headers: {
+            authorization: false,
+            'x-prelogin-userid': preLoginId,
+          },
+          method: 'POST',
+          resource: 'clientmetrics-prelogin',
+          service: 'metrics',
+          waitForServiceTimeout: 30,
+        });
+        assert.lengthOf(
+          webex.internal.newMetrics.callDiagnosticMetrics.preLoginMetricsBatcher.queue,
+          0
+        );
+      });
+
+      it('when the request fails, does not clear the queue', async () => {
+        webex.request = sinon.stub().rejects(new Error('my_error'));
+
+        webex.logger.error = sinon.stub();
+        webex.logger.log = sinon.stub();
+        sinon.stub(Utils, 'generateCommonErrorMetadata').returns('formattedError');
+
+        const promise =
+          webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnosticsPreLogin(
+            {
+              event: 'my.event',
+            },
+            preLoginId
+          );
+
+        await flushPromises();
+        clock.tick(config.metrics.batcherWait);
+
+        let error;
+
+        // catch the expected error and store it
+        try {
+          await promise;
+        } catch (err) {
+          error = err;
+        }
+
+        // This is horrific, but stubbing lodash is proving difficult
+        const expectedBatchId = parseInt(uniqueId()) - 1;
+
+        assert.equal(error.message, 'my_error');
+        assert.calledOnceWithExactly(
+          webex.logger.error,
+          'Pre Login Metrics -->',
+          `PreLoginMetricsBatcher: @submitHttpRequest#prelogin-ca-batch-${expectedBatchId}. Request failed:`,
+          `error: formattedError`
+        );
+        assert.lengthOf(
+          webex.internal.newMetrics.callDiagnosticMetrics.preLoginMetricsBatcher.queue,
+          0
+        );
+      });
+
+      it('fails if preLoinId is not set', async () => {
+        webex.internal.newMetrics.callDiagnosticMetrics.preLoginMetricsBatcher.preLoginId = undefined;
+
+        const promise =
+          webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnosticsPreLogin(
+            {
+              event: 'my.event',
+            },
+            undefined
+          );
+
+        await flushPromises();
+        clock.tick(config.metrics.batcherWait);
+
+        let error;
+
+        // catch the expected error and store it
+        try {
+          await promise;
+        } catch (err) {
+          error = err;
+        }
+
+        assert.equal(error.message, 'PreLoginId is not set.');
+      });
+    });
+
+    describe('prepareItem', () => {
+      it('calls prepareDiagnosticMetricItem correctly', async () => {
+         // avoid setting .sent timestamp
+        webex.internal.newMetrics.callDiagnosticMetrics.preLoginMetricsBatcher.prepareRequest = (q) =>
+          Promise.resolve(q);
+
+        const prepareItemSpy = sinon.spy(
+          webex.internal.newMetrics.callDiagnosticMetrics.preLoginMetricsBatcher,
+          'prepareItem'
+        );
+        const prepareDiagnosticMetricItemSpy = sinon.spy(
+          CallDiagnosticUtils,
+          'prepareDiagnosticMetricItem'
+        );
+
+        const promise =
+          webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnosticsPreLogin(
+            {
+              event: 'my.event',
+            },
+            preLoginId
+          );
+
+        await flushPromises();
+
+        clock.tick(config.metrics.batcherWait);
+
+        await promise;
+
+        const calls = prepareItemSpy.getCalls()[0];
+
+        // item also gets assigned a delay property but the key is a Symbol and haven't been able to test that..
+        assert.deepEqual(calls.args[0].eventPayload, {
+          event: 'my.event',
+          origin: {buildType: 'test', networkType: 'unknown'},
+        });
+
+        assert.deepEqual(calls.args[0].type, ['diagnostic-event']);
+
+        const prepareDiagnosticMetricItemCalls = prepareDiagnosticMetricItemSpy.getCalls();
+
+        // second argument (item) also gets assigned a delay property but the key is a Symbol and haven't been able to test that..
+        assert.deepEqual(prepareDiagnosticMetricItemCalls[0].args[0], webex);
+        assert.deepEqual(prepareDiagnosticMetricItemCalls[0].args[1].eventPayload, {
+          event: 'my.event',
+          origin: {
+            buildType: 'test',
+            networkType: 'unknown',
+          },
+        });
+        assert.deepEqual(prepareDiagnosticMetricItemCalls[0].args[1].type, ['diagnostic-event']);
+      });
+    });
+
+    describe('savePreLoginId', () => {
+      it('saves the preLoginId', () => {
+        const preLoginId = 'my_prelogin_id';
+
+        assert.isUndefined(
+          webex.internal.newMetrics.callDiagnosticMetrics.preLoginMetricsBatcher.preLoginId
+        );
+
+        webex.internal.newMetrics.callDiagnosticMetrics.preLoginMetricsBatcher.savePreLoginId(
+          preLoginId
+        );
+
+        assert.equal(
+          webex.internal.newMetrics.callDiagnosticMetrics.preLoginMetricsBatcher.preLoginId,
+          preLoginId
+        );
+      });
+    });
+  });
+});