@webex/internal-plugin-metrics 3.0.0-beta.162 → 3.0.0-beta.163

package/src/index.ts

@@ -0,0 +1,39 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import '@webex/internal-plugin-device';
+
+import {registerInternalPlugin} from '@webex/webex-core';
+
+import Metrics from './metrics';
+import config from './config';
+import NewMetrics from './new-metrics';
+import {
+  ClientEvent,
+  SubmitBehavioralEvent,
+  SubmitClientEvent,
+  SubmitInternalEvent,
+  SubmitOperationalEvent,
+  SubmitMQE,
+} from './metrics.types';
+import * as CALL_DIAGNOSTIC_CONFIG from './call-diagnostic/config';
+
+registerInternalPlugin('metrics', Metrics, {
+  config,
+});
+
+registerInternalPlugin('newMetrics', NewMetrics, {
+  config,
+});
+
+export {default, getOSNameInternal} from './metrics';
+export {config, CALL_DIAGNOSTIC_CONFIG, NewMetrics};
+export type {
+  ClientEvent,
+  SubmitBehavioralEvent,
+  SubmitClientEvent,
+  SubmitInternalEvent,
+  SubmitMQE,
+  SubmitOperationalEvent,
+};

package/src/metrics.js

@@ -10,7 +10,6 @@ import {OS_NAME, OSMap, CLIENT_NAME} from './config';
 
 import Batcher from './batcher';
 import ClientMetricsBatcher from './client-metrics-batcher';
-import CallDiagnosticEventsBatcher from './call-diagnostic-events-batcher';
 
 const {getOSName, getOSVersion, getBrowserName, getBrowserVersion} = BrowserDetection();
 
@@ -38,7 +37,6 @@ const Metrics = WebexPlugin.extend({
   children: {
     batcher: Batcher,
     clientMetricsBatcher: ClientMetricsBatcher,
-    callDiagnosticEventsBatcher: CallDiagnosticEventsBatcher,
   },
 
   namespace: 'Metrics',
@@ -163,15 +161,6 @@ const Metrics = WebexPlugin.extend({
       })
     );
   },
-
-  submitCallDiagnosticEvents(payload) {
-    const event = {
-      type: 'diagnostic-event',
-      eventPayload: payload,
-    };
-
-    return this.callDiagnosticEventsBatcher.request(event);
-  },
 });
 
 export default Metrics;

package/src/metrics.types.ts

@@ -0,0 +1,132 @@
+import {ClientEvent as RawClientEvent} from './call-diagnostic/generated-types-temp/ClientEvent';
+import {Event as RawEvent} from './call-diagnostic/generated-types-temp/Event';
+import {MediaQualityEvent as RawMediaQualityEvent} from './call-diagnostic/generated-types-temp/MediaQualityEvent';
+
+export type Event = Omit<RawEvent, 'event'> & {event: RawClientEvent | RawMediaQualityEvent};
+
+export type ClientEventError = NonNullable<RawClientEvent['errors']>[0];
+
+export type SubmitClientEventOptions = {
+  meetingId?: string;
+  mediaConnections?: any[];
+  rawError?: any;
+  showToUser?: boolean;
+  correlationId?: string;
+};
+
+export type SubmitMQEOptions = {
+  meetingId: string;
+  mediaConnections?: any[];
+  networkType?: Event['origin']['networkType'];
+};
+
+export type InternalEvent = {
+  name:
+    | 'internal.client.meetinginfo.request'
+    | 'internal.client.meetinginfo.response'
+    | 'internal.reset.join.latencies'
+    | 'internal.client.interstitial-window.launched'
+    | 'internal.client.meeting.click.joinbutton'
+    | 'internal.host.meeting.participant.admitted'
+    | 'internal.client.meeting.interstitial-window.showed'
+    | 'internal.client.pageJMT.received'
+    | 'internal.client.interstitial-window.click.joinbutton';
+  payload?: never;
+  options?: never;
+};
+
+export interface ClientEvent {
+  name: RawClientEvent['name'];
+  payload?: RawClientEvent;
+  options: SubmitClientEventOptions;
+}
+
+export interface BehavioralEvent {
+  // TODO: not implemented
+  name: 'host.meeting.participant.admitted' | 'sdk.media-flow.started';
+  payload?: never;
+  options?: never;
+}
+
+export interface OperationalEvent {
+  // TODO: not implemented
+  name: never;
+  payload?: never;
+  options?: never;
+}
+
+export interface FeatureEvent {
+  // TODO: not implemented
+  name: never;
+  payload?: never;
+  options?: never;
+}
+
+export interface MediaQualityEvent {
+  name: RawMediaQualityEvent['name'];
+  payload?: RawMediaQualityEvent;
+  options: SubmitMQEOptions;
+}
+
+export type RecursivePartial<T> = {
+  [P in keyof T]?: T[P] extends (infer U)[]
+    ? RecursivePartial<U>[]
+    : T[P] extends object
+    ? RecursivePartial<T[P]>
+    : T[P];
+};
+
+export type MetricEventNames =
+  | InternalEvent['name']
+  | ClientEvent['name']
+  | BehavioralEvent['name']
+  | OperationalEvent['name']
+  | FeatureEvent['name']
+  | MediaQualityEvent['name'];
+
+export type ClientType = NonNullable<RawEvent['origin']['clientInfo']>['clientType'];
+export type SubClientType = NonNullable<RawEvent['origin']['clientInfo']>['subClientType'];
+export type NetworkType = RawEvent['origin']['networkType'];
+
+export type ClientEventPayload = RecursivePartial<ClientEvent['payload']>;
+
+export type MediaQualityEventAudioSetupDelayPayload =
+  MediaQualityEvent['payload']['audioSetupDelay'];
+export type MediaQualityEventVideoSetupDelayPayload =
+  MediaQualityEvent['payload']['videoSetupDelay'];
+
+export type SubmitMQEPayload = RecursivePartial<MediaQualityEvent['payload']> & {
+  intervals: MediaQualityEvent['payload']['intervals'];
+};
+
+export type SubmitInternalEvent = (args: {
+  name: InternalEvent['name'];
+  payload?: RecursivePartial<InternalEvent['payload']>;
+  options: any;
+}) => void;
+
+export type SubmitBehavioralEvent = (args: {
+  name: BehavioralEvent['name'];
+  payload?: RecursivePartial<BehavioralEvent['payload']>;
+  options: any;
+}) => void;
+
+export type SubmitClientEvent = (args: {
+  name: ClientEvent['name'];
+  payload?: RecursivePartial<ClientEvent['payload']>;
+  options: SubmitClientEventOptions;
+}) => void;
+
+export type SubmitOperationalEvent = (args: {
+  name: OperationalEvent['name'];
+  payload?: RecursivePartial<OperationalEvent['payload']>;
+  options: any;
+}) => void;
+
+export type SubmitMQE = (args: {
+  name: MediaQualityEvent['name'];
+  payload: RecursivePartial<MediaQualityEvent['payload']> & {
+    intervals: MediaQualityEvent['payload']['intervals'];
+  };
+  options: any;
+}) => void;

package/src/new-metrics.ts

@@ -0,0 +1,167 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable class-methods-use-this */
+/* eslint-disable valid-jsdoc */
+
+// @ts-ignore
+import {WebexPlugin} from '@webex/webex-core';
+
+import CallDiagnosticMetrics from './call-diagnostic/call-diagnostic-metrics';
+import {
+  RecursivePartial,
+  ClientEvent,
+  FeatureEvent,
+  BehavioralEvent,
+  OperationalEvent,
+  MediaQualityEvent,
+  InternalEvent,
+  SubmitClientEventOptions,
+} from './metrics.types';
+import CallDiagnosticLatencies from './call-diagnostic/call-diagnostic-metrics-latencies';
+
+/**
+ * Metrics plugin to centralize all types of metrics.
+ * @class
+ */
+class Metrics extends WebexPlugin {
+  // eslint-disable-next-line no-use-before-define
+  static instance: Metrics;
+
+  // Call Diagnostic latencies
+  callDiagnosticLatencies: CallDiagnosticLatencies;
+  // Helper classes to handle the different types of metrics
+  callDiagnosticMetrics: CallDiagnosticMetrics;
+
+  /**
+   * Constructor
+   * @param args
+   * @constructor
+   * @private
+   * @returns
+   */
+  constructor(...args) {
+    super(...args);
+
+    this.callDiagnosticLatencies = new CallDiagnosticLatencies();
+
+    this.onReady();
+  }
+
+  /**
+   * On Ready
+   */
+  private onReady() {
+    // @ts-ignore
+    this.webex.once('ready', () => {
+      // @ts-ignore
+      this.callDiagnosticMetrics = new CallDiagnosticMetrics({}, {parent: this.webex});
+    });
+  }
+
+  /**
+   * Used for internal purposes only
+   * @param args
+   */
+  submitInternalEvent({
+    name,
+    payload,
+    options,
+  }: {
+    name: InternalEvent['name'];
+    payload?: RecursivePartial<InternalEvent['payload']>;
+    options: any;
+  }) {
+    if (name === 'internal.reset.join.latencies') {
+      this.callDiagnosticLatencies.clearTimestamps();
+    } else {
+      this.callDiagnosticLatencies.saveTimestamp(name);
+    }
+  }
+
+  /**
+   * Behavioral event
+   * @param args
+   */
+  submitBehavioralEvent({
+    name,
+    payload,
+    options,
+  }: {
+    name: BehavioralEvent['name'];
+    payload?: RecursivePartial<BehavioralEvent['payload']>;
+    options: any;
+  }) {
+    this.callDiagnosticLatencies.saveTimestamp(name);
+    throw new Error('Not implemented.');
+  }
+
+  /**
+   * Operational event
+   * @param args
+   */
+  submitOperationalEvent({
+    name,
+    payload,
+    options,
+  }: {
+    name: OperationalEvent['name'];
+    payload?: RecursivePartial<OperationalEvent['payload']>;
+    options: any;
+  }) {
+    throw new Error('Not implemented.');
+  }
+
+  /**
+   * Call Analyzer: Media Quality Event
+   * @param args
+   */
+  submitMQE({
+    name,
+    payload,
+    options,
+  }: {
+    name: MediaQualityEvent['name'];
+    payload: RecursivePartial<MediaQualityEvent['payload']> & {
+      intervals: MediaQualityEvent['payload']['intervals'];
+    };
+    options: any;
+  }) {
+    this.callDiagnosticLatencies.saveTimestamp(name);
+    this.callDiagnosticMetrics.submitMQE({name, payload, options});
+  }
+
+  /**
+   * Call Analyzer: Feature Usage Event
+   * @param args
+   */
+  submitFeatureEvent({
+    name,
+    payload,
+    options,
+  }: {
+    name: FeatureEvent['name'];
+    payload?: RecursivePartial<FeatureEvent['payload']>;
+    options: any;
+  }) {
+    throw new Error('Not implemented.');
+  }
+
+  /**
+   * Call Analyzer: Client Event
+   * @public
+   * @param args
+   */
+  public submitClientEvent({
+    name,
+    payload,
+    options,
+  }: {
+    name: ClientEvent['name'];
+    payload?: RecursivePartial<ClientEvent['payload']>;
+    options: SubmitClientEventOptions;
+  }) {
+    this.callDiagnosticLatencies.saveTimestamp(name);
+    this.callDiagnosticMetrics.submitClientEvent({name, payload, options});
+  }
+}
+
+export default Metrics;

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

@@ -0,0 +1,233 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import {assert} from '@webex/test-helper-chai';
+import {config} from '@webex/internal-plugin-metrics';
+import MockWebex from '@webex/test-helper-mock-webex';
+import sinon from 'sinon';
+import {NewMetrics} from '@webex/internal-plugin-metrics';
+const flushPromises = () => new Promise(setImmediate);
+
+describe('plugin-metrics', () => {
+  describe('CallDiagnosticEventsBatcher', () => {
+    let webex;
+
+    beforeEach(() => {
+      //@ts-ignore
+      webex = new MockWebex({
+        children: {
+          newMetrics: NewMetrics
+        }
+      });
+
+      webex.request = (options) => Promise.resolve({body: {items: []}, options});
+      sinon.spy(webex, 'request');
+
+      webex.emit("ready");
+
+      webex.config.metrics = config.metrics;
+    });
+
+    afterEach(() => {
+      sinon.restore();
+    });
+
+    describe('#request()', () => {
+      describe('when the request completes successfully', async () => {
+        it('clears the queue', async () => {
+          await webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
+            //@ts-ignore
+            {event: {name: 'client.interstitial-window.launched'}}
+          );
+          await flushPromises();
+
+          //@ts-ignore
+          assert.calledOnce(webex.request);
+          assert.lengthOf(webex.internal.newMetrics.callDiagnosticMetrics.callDiagnosticEventsBatcher.queue, 0);
+        });
+
+        it('doesnt include any joinTimes for other events', async () => {
+          await webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
+            //@ts-ignore
+            {event: {name: 'client.alert.displayed'}}
+          );
+          await flushPromises();
+
+          //@ts-ignore
+          assert.calledOnce(webex.request);
+          assert.deepEqual(webex.request.getCalls()[0].args[0].body.metrics[0].eventPayload.event, {
+            name: 'client.alert.displayed',
+          });
+          assert.lengthOf(webex.internal.newMetrics.callDiagnosticMetrics.callDiagnosticEventsBatcher.queue, 0);
+        });
+
+        it('appends the correct join times to the request for client.interstitial-window.launched', async () => {
+          webex.internal.newMetrics.callDiagnosticLatencies.getDiffBetweenTimestamps = sinon.stub().returns(10);
+          await webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
+            //@ts-ignore
+            {event: {name: 'client.interstitial-window.launched'}}
+          );
+          await flushPromises();
+
+          //@ts-ignore
+          assert.calledOnce(webex.request);
+          assert.deepEqual(webex.request.getCalls()[0].args[0].body.metrics[0].eventPayload.event, {
+            name: 'client.interstitial-window.launched',
+            joinTimes: {
+              clickToInterstitial: 10,
+              meetingInfoReqResp: 10,
+            },
+          });
+          assert.lengthOf(webex.internal.newMetrics.callDiagnosticMetrics.callDiagnosticEventsBatcher.queue, 0);
+        });
+
+        it('appends the correct join times to the request for client.call.initiated', async () => {
+          webex.internal.newMetrics.callDiagnosticLatencies.getDiffBetweenTimestamps = sinon.stub().returns(10);
+          await webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
+            //@ts-ignore
+            {event: {name: 'client.call.initiated'}}
+          );
+          await flushPromises();
+
+          //@ts-ignore
+          assert.calledOnce(webex.request);
+          assert.deepEqual(webex.request.getCalls()[0].args[0].body.metrics[0].eventPayload.event, {
+            name: 'client.call.initiated',
+            joinTimes: {
+              meetingInfoReqResp: 10,
+              showInterstitialTime: 10,
+            },
+          });
+          assert.lengthOf(webex.internal.newMetrics.callDiagnosticMetrics.callDiagnosticEventsBatcher.queue, 0);
+        });
+
+        it('appends the correct join times to the request for client.locus.join.response', async () => {
+          webex.internal.newMetrics.callDiagnosticLatencies.getDiffBetweenTimestamps = sinon.stub().returns(10);
+          webex.internal.newMetrics.callDiagnosticLatencies.getJoinRespSentReceived = sinon.stub().returns(20);
+          webex.internal.newMetrics.callDiagnosticLatencies.getPageJMT = sinon.stub().returns(30);
+          await webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
+            //@ts-ignore
+            {event: {name: 'client.locus.join.response'}}
+          );
+          await flushPromises();
+
+          //@ts-ignore
+          assert.calledOnce(webex.request);
+          assert.deepEqual(webex.request.getCalls()[0].args[0].body.metrics[0].eventPayload.event, {
+            name: 'client.locus.join.response',
+            joinTimes: {
+              callInitJoinReq: 10,
+              clickToInterstitial: 10,
+              interstitialToJoinOK: 10,
+              joinReqResp: 10,
+              joinReqSentReceived: 20,
+              meetingInfoReqResp: 10,
+              pageJmt: 30,
+              totalJmt: 20,
+            },
+          });
+          assert.lengthOf(webex.internal.newMetrics.callDiagnosticMetrics.callDiagnosticEventsBatcher.queue, 0);
+        });
+
+        it('appends the correct join times to the request for client.ice.end', async () => {
+          webex.internal.newMetrics.callDiagnosticLatencies.getDiffBetweenTimestamps = sinon.stub().returns(10);
+          await webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
+            //@ts-ignore
+            {event: {name: 'client.ice.end'}}
+          );
+          await flushPromises();
+
+          //@ts-ignore
+          assert.calledOnce(webex.request);
+          assert.deepEqual(webex.request.getCalls()[0].args[0].body.metrics[0].eventPayload.event, {
+            name: 'client.ice.end',
+            joinTimes: {
+              ICESetupTime: 10,
+              audioICESetupTime: 10,
+              shareICESetupTime: 10,
+              videoICESetupTime: 10,
+            },
+          });
+          assert.lengthOf(webex.internal.newMetrics.callDiagnosticMetrics.callDiagnosticEventsBatcher.queue, 0);
+        });
+
+        it('appends the correct join times to the request for client.media.rx.start', async () => {
+          webex.internal.newMetrics.callDiagnosticLatencies.getDiffBetweenTimestamps = sinon.stub().returns(10);
+          await webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
+            //@ts-ignore
+            {event: {name: 'client.media.rx.start'}}
+          );
+          await flushPromises();
+
+          //@ts-ignore
+          assert.calledOnce(webex.request);
+          assert.deepEqual(webex.request.getCalls()[0].args[0].body.metrics[0].eventPayload.event, {
+            name: 'client.media.rx.start',
+            joinTimes: {
+              localSDPGenRemoteSDPRecv: 10,
+            },
+          });
+          assert.lengthOf(webex.internal.newMetrics.callDiagnosticMetrics.callDiagnosticEventsBatcher.queue, 0);
+        });
+
+        it('appends the correct join times to the request for client.media-engine.ready', async () => {
+          webex.internal.newMetrics.callDiagnosticLatencies.getDiffBetweenTimestamps = sinon.stub().returns(10)
+          await webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
+            //@ts-ignore
+            {event: {name: 'client.media-engine.ready'}}
+          );
+          await flushPromises();
+
+          //@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,
+            },
+          });
+          assert.lengthOf(webex.internal.newMetrics.callDiagnosticMetrics.callDiagnosticEventsBatcher.queue, 0);
+        });
+
+        it('appends the correct audio and video setup delays to the request for client.mediaquality.event', async () => {
+          webex.internal.newMetrics.callDiagnosticLatencies.getDiffBetweenTimestamps = sinon.stub().returns(10);
+          await  webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
+            //@ts-ignore
+            {event: {name: 'client.mediaquality.event'}}
+          );
+          await flushPromises();
+
+          //@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,
+            }
+          });
+          assert.lengthOf(webex.internal.newMetrics.callDiagnosticMetrics.callDiagnosticEventsBatcher.queue, 0);
+        });
+
+        it('doesnt include audioSetup and videoSetup delays for other events', async () => {
+          await  webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
+            //@ts-ignore
+            {event: {name: 'client.alert.displayed'}}
+          );
+          await flushPromises();
+
+          //@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);
+        })
+      });
+    });
+  });
+});