@webex/internal-plugin-metrics 3.0.0-beta.4 → 3.0.0-beta.400

package/test/unit/spec/client-metrics-batcher.js

@@ -27,8 +27,8 @@ describe('plugin-metrics', () => {
     beforeEach(() => {
       webex = new MockWebex({
         children: {
-          metrics: Metrics
-        }
+          metrics: Metrics,
+        },
       });
 
       webex.config.metrics = config.metrics;
@@ -37,7 +37,8 @@ describe('plugin-metrics', () => {
         return Promise.resolve({
           statusCode: 204,
           body: undefined,
-          options
+          waitForServiceTimeout: 30,
+          options,
         });
       };
       sinon.spy(webex, 'request');
@@ -58,9 +59,10 @@ describe('plugin-metrics', () => {
         it('clears the queue', () => {
           clock.uninstall();
 
-          return webex.internal.metrics.clientMetricsBatcher.request({
-            key: 'testMetric'
-          })
+          return webex.internal.metrics.clientMetricsBatcher
+            .request({
+              key: 'testMetric',
+            })
             .then(() => {
               assert.calledOnce(webex.request);
               assert.lengthOf(webex.internal.metrics.clientMetricsBatcher.queue, 0);
@@ -80,26 +82,29 @@ describe('plugin-metrics', () => {
 
           sinon.stub(webex, 'request').callsFake((options) => {
             options.headers = {
-              trackingid: count
+              trackingid: count,
             };
 
             count += 1;
             if (count < 9) {
-              return Promise.reject(new WebexHttpError.NetworkOrCORSError({
-                statusCode: 0,
-                options
-              }));
+              return Promise.reject(
+                new WebexHttpError.NetworkOrCORSError({
+                  statusCode: 0,
+                  options,
+                })
+              );
             }
 
             return Promise.resolve({
               statusCode: 204,
               body: undefined,
-              options
+              waitForServiceTimeout: 30,
+              options,
             });
           });
 
           const promise = webex.internal.metrics.clientMetricsBatcher.request({
-            key: 'testMetric'
+            key: 'testMetric',
           });
 
           return promiseTick(50)
@@ -159,8 +164,16 @@ describe('plugin-metrics', () => {
             .then(() => assert.lengthOf(webex.internal.metrics.clientMetricsBatcher.queue, 0))
             .then(() => promise)
             .then(() => {
-              assert.lengthOf(webex.request.args[1][0].body.metrics, 1, 'Reenqueuing the metric once did not increase the number of metrics to be submitted');
-              assert.lengthOf(webex.request.args[2][0].body.metrics, 1, 'Reenqueuing the metric twice did not increase the number of metrics to be submitted');
+              assert.lengthOf(
+                webex.request.args[1][0].body.metrics,
+                1,
+                'Reenqueuing the metric once did not increase the number of metrics to be submitted'
+              );
+              assert.lengthOf(
+                webex.request.args[2][0].body.metrics,
+                1,
+                'Reenqueuing the metric twice did not increase the number of metrics to be submitted'
+              );
               assert.lengthOf(webex.internal.metrics.clientMetricsBatcher.queue, 0);
             });
         });

package/test/unit/spec/metrics.js

@@ -8,6 +8,9 @@ import {Token, Credentials} from '@webex/webex-core';
 import FakeTimers from '@sinonjs/fake-timers';
 import sinon from 'sinon';
 import Metrics, {config} from '@webex/internal-plugin-metrics';
+import {BrowserDetection} from '@webex/common';
+
+const {getOSVersion} = BrowserDetection();
 
 function promiseTick(count) {
   let promise = Promise.resolve();
@@ -29,35 +32,35 @@ describe('plugin-metrics', () => {
     const eventName = 'test_event';
     const mockPayload = {
       fields: {
-        testField: 123
+        testField: 123,
       },
       tags: {
-        testTag: 'tag value'
+        testTag: 'tag value',
       },
       metricName: eventName,
       test: 'this field should not be included in final payload',
       type: 'behavioral',
-      eventPayload: {value: 'splunk business metric payload'}
+      eventPayload: {value: 'splunk business metric payload'},
     };
     const transformedProps = {
       fields: {
-        testField: 123
+        testField: 123,
       },
       tags: {
-        testTag: 'tag value'
+        testTag: 'tag value',
       },
       metricName: eventName,
       type: 'behavioral',
-      timestamp: Date.now()
+      timestamp: Date.now(),
     };
     const preLoginId = '1b90cf5e-27a6-41aa-a208-1f6eb6b9e6b6';
     const preLoginProps = {
-      metrics: [transformedProps]
+      metrics: [transformedProps],
     };
     const mockCallDiagnosticEvent = {
       originTime: {
-        triggered: 'mock triggered timestamp'
-      }
+        triggered: 'mock triggered timestamp',
+      },
     };
 
     beforeEach(() => {
@@ -71,8 +74,8 @@ describe('plugin-metrics', () => {
     beforeEach(() => {
       webex = new MockWebex({
         children: {
-          metrics: Metrics
-        }
+          metrics: Metrics,
+        },
       });
 
       webex.config.metrics = config.metrics;
@@ -82,7 +85,8 @@ describe('plugin-metrics', () => {
         return Promise.resolve({
           statusCode: 204,
           body: undefined,
-          options
+          waitForServiceTimeout: 30,
+          options,
         });
       };
 
@@ -94,16 +98,21 @@ describe('plugin-metrics', () => {
         ...webex.config,
         appName: 'appName',
         appPlatform: 'appPlatform',
-        appVersion: 'appVersion'
-
+        appVersion: 'appVersion',
       };
       webex.config.metrics.type = ['operational'];
       webex.config.metrics.appType = 'sdk';
+      webex.meetings = {
+        config: {
+          metrics: {
+            clientVersion: '43.0.105'
+          }
+        }
+      }
 
       sinon.spy(webex, 'request');
       sinon.spy(metrics, 'postPreLoginMetric');
       sinon.spy(metrics, 'aliasUser');
-      sinon.spy(metrics, 'submitCallDiagnosticEvents');
     });
 
     describe('#submit()', () => {
@@ -132,6 +141,68 @@ describe('plugin-metrics', () => {
       });
     });
 
+    describe('#getClientMetricsPayload()', () => {
+      it('returns the expected payload', () => {
+        webex.credentials.supertoken = new Token(
+          {
+            access_token: 'a_b_orgid',
+          },
+          {parent: webex}
+        );
+
+        const testPayload = {
+          tags: {success: true},
+          fields: {perceivedDurationInMillis: 314},
+          context: {},
+          eventPayload: {value: 'splunk business metric payload'},
+        };
+        const date = clock.now;
+
+        const result = metrics.getClientMetricsPayload('test', testPayload);
+
+        assert.deepEqual(result, {
+          context: {
+            app: {
+              version: undefined,
+            },
+            locale: 'en-US',
+            os: {
+              name: 'other',
+              version: getOSVersion(),
+            },
+          },
+          eventPayload: {
+            value: 'splunk business metric payload',
+          },
+          fields: {
+            browser_version: '',
+            client_id: 'fake',
+            os_version: getOSVersion(),
+            perceivedDurationInMillis: 314,
+            platform: 'Web',
+            sdk_version: undefined,
+            spark_user_agent: 'webex-js-sdk appName/appVersion appPlatform',
+          },
+          metricName: 'test',
+          tags: {
+            appVersion: '43.0.105',
+            browser: '',
+            domain: 'whatever',
+            os: 'other',
+            success: true,
+          },
+          timestamp: 0,
+          type: ['operational'],
+        });
+      });
+
+      it('throws when no event name is specified', () => {
+        assert.throws(() => {
+          metrics.getClientMetricsPayload();
+        }, 'Missing behavioral metric name. Please provide one');
+      });
+    });
+
     describe('#submitClientMetrics()', () => {
       describe('before login', () => {
         it('posts pre-login metric', () => {
@@ -167,15 +238,18 @@ describe('plugin-metrics', () => {
       });
       describe('after login', () => {
         it('submits a metric to clientmetrics', () => {
-          webex.credentials.supertoken = new Token({
-            access_token: 'a_b_orgid'
-          }, {parent: webex});
+          webex.credentials.supertoken = new Token(
+            {
+              access_token: 'a_b_orgid',
+            },
+            {parent: webex}
+          );
 
           const testPayload = {
             tags: {success: true},
             fields: {perceivedDurationInMillis: 314},
             context: {},
-            eventPayload: {value: 'splunk business metric payload'}
+            eventPayload: {value: 'splunk business metric payload'},
           };
           const date = clock.now;
 
@@ -197,23 +271,20 @@ describe('plugin-metrics', () => {
               assert.property(metric, 'eventPayload');
 
               assert.property(metric.tags, 'browser');
-              assert.property(metric.tags, 'org_id');
               assert.property(metric.tags, 'os');
               assert.property(metric.tags, 'domain');
-              assert.property(metric.tags, 'client_id');
-              assert.property(metric.tags, 'user_id');
 
               assert.property(metric.fields, 'browser_version');
               assert.property(metric.fields, 'os_version');
               assert.property(metric.fields, 'sdk_version');
               assert.property(metric.fields, 'platform');
               assert.property(metric.fields, 'spark_user_agent');
+              assert.property(metric.fields, 'client_id');
 
               assert.property(metric.context, 'app');
               assert.property(metric.context, 'locale');
               assert.property(metric.context, 'os');
 
-
               assert.equal(metric.timestamp, date);
               assert.equal(metric.metricName, 'test');
               assert.equal(metric.tags.success, true);
@@ -268,98 +339,5 @@ describe('plugin-metrics', () => {
           assert.match(params, {alias: true});
         }));
     });
-
-    describe('#submitCallDiagnosticEvents()', () => {
-      it('submits a call diagnostic event', () => {
-        const promise = metrics.submitCallDiagnosticEvents(mockCallDiagnosticEvent);
-
-        return promiseTick(50)
-          .then(() => clock.tick(config.metrics.batcherWait))
-          .then(() => promise)
-          .then(() => {
-            assert.calledOnce(webex.request);
-            const req = webex.request.args[0][0];
-            const metric = req.body.metrics[0];
-
-            assert.property(metric.eventPayload, 'origin');
-            assert.property(metric.eventPayload, 'originTime');
-            assert.property(metric.eventPayload.origin, 'buildType');
-            assert.property(metric.eventPayload.origin, 'networkType');
-            assert.property(metric.eventPayload.originTime, 'sent');
-            assert.equal(metric.eventPayload.origin.buildType, 'test');
-          });
-      });
-
-      it('submits a call diagnostic event with buildType set in the payload', () => {
-        const promise = metrics.submitCallDiagnosticEvents({
-          ...mockCallDiagnosticEvent,
-          origin: {
-            buildType: 'prod'
-          }
-        });
-
-        return promiseTick(50)
-          .then(() => clock.tick(config.metrics.batcherWait))
-          .then(() => promise)
-          .then(() => {
-            assert.calledOnce(webex.request);
-            const req = webex.request.args[0][0];
-            const metric = req.body.metrics[0];
-
-            assert.property(metric.eventPayload, 'origin');
-            assert.property(metric.eventPayload, 'originTime');
-            assert.property(metric.eventPayload.origin, 'buildType');
-            assert.property(metric.eventPayload.origin, 'networkType');
-            assert.property(metric.eventPayload.originTime, 'sent');
-            assert.equal(metric.eventPayload.origin.buildType, 'prod');
-          });
-      });
-
-      xit('submits a call diagnostic event with a test domain', () => {
-        global.window.location.hostname = 'test.webex.com';
-
-        const promise = metrics.submitCallDiagnosticEvents(mockCallDiagnosticEvent);
-
-        return promiseTick(50)
-          .then(() => clock.tick(config.metrics.batcherWait))
-          .then(() => promise)
-          .then(() => {
-            assert.calledOnce(webex.request);
-            const req = webex.request.args[0][0];
-            const metric = req.body.metrics[0];
-
-            assert.property(metric.eventPayload, 'origin');
-            assert.property(metric.eventPayload, 'originTime');
-            assert.property(metric.eventPayload.origin, 'buildType');
-            assert.property(metric.eventPayload.origin, 'networkType');
-            assert.property(metric.eventPayload.originTime, 'sent');
-            assert.equal(metric.eventPayload.origin.buildType, 'test');
-          });
-      });
-
-      // Skip because it's current unable to overwrite NODE_ENV
-      // However doing `NODE_ENV=test npm run test ...` will get this test case to pass
-      xit('submits a call diagnostic event with a NODE_ENV=production', () => {
-        process.env.NODE_ENV = 'production';
-
-        const promise = metrics.submitCallDiagnosticEvents(mockCallDiagnosticEvent);
-
-        return promiseTick(50)
-          .then(() => clock.tick(config.metrics.batcherWait))
-          .then(() => promise)
-          .then(() => {
-            assert.calledOnce(webex.request);
-            const req = webex.request.args[0][0];
-            const metric = req.body.metrics[0];
-
-            assert.property(metric.eventPayload, 'origin');
-            assert.property(metric.eventPayload, 'originTime');
-            assert.property(metric.eventPayload.origin, 'buildType');
-            assert.property(metric.eventPayload.origin, 'networkType');
-            assert.property(metric.eventPayload.originTime, 'sent');
-            assert.equal(metric.eventPayload.origin.buildType, 'prod');
-          });
-      });
-    });
   });
 });

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

@@ -0,0 +1,231 @@
+import {assert} from '@webex/test-helper-chai';
+import {NewMetrics, CallDiagnosticLatencies} from '@webex/internal-plugin-metrics';
+import MockWebex from '@webex/test-helper-mock-webex';
+import sinon from 'sinon';
+import {Utils} from '@webex/internal-plugin-metrics';
+
+describe('internal-plugin-metrics', () => {
+
+  const mockWebex = () => new MockWebex({
+    children: {
+      newMetrics: NewMetrics,
+    },
+    meetings: {
+      meetingCollection: {
+        get: sinon.stub(),
+      },
+    },
+    request: sinon.stub().resolves({}),
+    logger: {
+      log: sinon.stub(),
+      error: sinon.stub(),
+    }
+  });
+
+  describe('check submitClientEvent when webex is not ready', () => {
+    let webex;
+    //@ts-ignore
+    webex = mockWebex();
+
+    it('checks the log', () => {
+      webex.internal.newMetrics.submitClientEvent({
+        name: 'client.alert.displayed',
+        options: {
+          meetingId: '123',
+        },
+      });
+      assert.calledWith(
+        webex.logger.log,
+        'NewMetrics: @submitClientEvent. Attempted to submit before webex.ready. Event name: client.alert.displayed'
+      );
+    });
+  });
+
+  describe('new-metrics contstructor', () => {
+    it('checks callDiagnosticLatencies is defined before ready emit', () => {
+
+      const webex = mockWebex();
+
+      assert.instanceOf(webex.internal.newMetrics.callDiagnosticLatencies, CallDiagnosticLatencies);
+    });
+  });
+
+  describe('new-metrics', () => {
+    let webex;
+
+    beforeEach(() => {
+      //@ts-ignore
+      webex = mockWebex();
+
+      webex.emit('ready');
+
+      webex.internal.newMetrics.callDiagnosticLatencies.saveTimestamp = sinon.stub();
+      webex.internal.newMetrics.callDiagnosticLatencies.clearTimestamps = sinon.stub();
+      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.buildClientEventFetchRequestOptions =
+        sinon.stub();
+      webex.setTimingsAndFetch = sinon.stub();
+    });
+
+    afterEach(() => {
+      sinon.restore();
+    })
+
+    it('submits Client Event successfully', () => {
+      webex.internal.newMetrics.submitClientEvent({
+        name: 'client.alert.displayed',
+        options: {
+          meetingId: '123',
+        },
+      });
+
+      assert.calledWith(webex.internal.newMetrics.callDiagnosticLatencies.saveTimestamp, {
+        key: 'client.alert.displayed',
+        options: {meetingId: '123'},
+      });
+      assert.calledWith(webex.internal.newMetrics.callDiagnosticMetrics.submitClientEvent, {
+        name: 'client.alert.displayed',
+        payload: undefined,
+        options: {meetingId: '123'},
+      });
+    });
+
+
+    it('submits MQE successfully', () => {
+      webex.internal.newMetrics.submitMQE({
+        name: 'client.mediaquality.event',
+        //@ts-ignore
+        payload: {intervals: [{}]},
+        options: {
+          meetingId: '123',
+          networkType: 'wifi',
+        },
+      });
+
+      assert.calledWith(webex.internal.newMetrics.callDiagnosticLatencies.saveTimestamp, {
+        key: 'client.mediaquality.event',
+      });
+      assert.calledWith(webex.internal.newMetrics.callDiagnosticMetrics.submitMQE, {
+        name: 'client.mediaquality.event',
+        //@ts-ignore
+        payload: {intervals: [{}]},
+        options: {
+          meetingId: '123',
+          networkType: 'wifi',
+        },
+      });
+    });
+
+    it('submits Internal Event successfully', () => {
+      webex.internal.newMetrics.submitInternalEvent({
+        name: 'client.mediaquality.event',
+      });
+
+      assert.calledWith(webex.internal.newMetrics.callDiagnosticLatencies.saveTimestamp, {
+        key: 'client.mediaquality.event',
+      });
+      assert.notCalled(webex.internal.newMetrics.callDiagnosticLatencies.clearTimestamps);
+    });
+
+    it('submits Internal Event successfully for clearing the join latencies', () => {
+      webex.internal.newMetrics.submitInternalEvent({
+        name: 'internal.reset.join.latencies',
+      });
+
+      assert.notCalled(webex.internal.newMetrics.callDiagnosticLatencies.saveTimestamp);
+      assert.calledOnce(webex.internal.newMetrics.callDiagnosticLatencies.clearTimestamps);
+    });
+
+    describe('#clientMetricsAliasUser', () => {
+      it('aliases the user correctly', async () => {
+        webex.request.resolves({response: 'abc'});
+        await webex.internal.newMetrics.clientMetricsAliasUser('my-id');
+        assert.calledWith(webex.request, {
+          method: 'POST',
+          api: 'metrics',
+          resource: 'clientmetrics',
+          headers: { 'x-prelogin-userid': 'my-id' },
+          body: {},
+          qs: { alias: true },
+        });
+        assert.calledWith(
+          webex.logger.log,
+          'NewMetrics: @clientMetricsAliasUser. 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.clientMetricsAliasUser({event: 'test'}, 'my-id');
+        } catch (err) {
+          assert.calledWith(
+            webex.logger.error,
+            'NewMetrics: @clientMetricsAliasUser. Request failed:',
+            `err: formattedError`
+          );
+        }
+      });
+    });
+
+    describe('#buildClientEventFetchRequestOptions', () => {
+      it('builds client event fetch options successfully', () => {
+        webex.internal.newMetrics.buildClientEventFetchRequestOptions({
+          name: 'client.alert.displayed',
+          options: {
+            meetingId: '123',
+          },
+        });
+
+        assert.calledWith(
+          webex.internal.newMetrics.callDiagnosticMetrics.buildClientEventFetchRequestOptions,
+          {
+            name: 'client.alert.displayed',
+            payload: undefined,
+            options: {meetingId: '123'},
+          }
+        );
+      });
+    });
+
+    describe('#setMetricTimingsAndFetch', () => {
+      beforeEach(() => {
+        global.fetch = sinon.stub();
+      });
+
+      it('calls fetch with the expected options', () => {
+        const now = new Date();
+        sinon.useFakeTimers(now.getTime());
+
+        webex.internal.newMetrics.setMetricTimingsAndFetch({
+          json: true,
+          body: JSON.stringify({metrics: [{eventPayload: {}}]}),
+        });
+
+        const expected = {
+          json: true,
+          body: JSON.stringify({
+            metrics: [
+              {
+                eventPayload: {
+                  originTime: {
+                    triggered: now.toISOString(),
+                    sent: now.toISOString(),
+                  },
+                },
+              },
+            ],
+          }),
+        };
+
+        sinon.assert.calledOnce(webex.setTimingsAndFetch);
+        sinon.assert.calledWith(webex.setTimingsAndFetch, expected);
+
+        sinon.restore();
+      });
+    });
+  });
+});