@webex/plugin-meetings 3.0.0-beta.162 → 3.0.0-beta.164

package/src/metrics/index.ts

@@ -1,66 +1,6 @@
 /*!
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
-import util from 'util';
-
-import {includes} from 'lodash';
-import uuid from 'uuid';
-import window from 'global/window';
-import anonymize from 'ip-anonymize';
-
-import {getOSNameInternal} from '@webex/internal-plugin-metrics';
-import LoggerProxy from '../common/logs/logger-proxy';
-import {MEETING_ERRORS} from '../constants';
-import BrowserDetection from '../common/browser-detection';
-
-import {
-  error,
-  eventType,
-  errorCodes as ERROR_CODE,
-  UNKNOWN,
-  CLIENT_NAME,
-  mediaType,
-  WebexAPIServiceErrorCodes,
-} from './config';
-
-const {getOSName, getOSVersion, getBrowserName, getBrowserVersion} = BrowserDetection();
-
-// Apply a CIDR /28 format to the IPV4 and /96 to the IPV6 addresses
-// For reference : https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing
-const anonymizeIPAddress = (localIp) => anonymize(localIp, 28, 96);
-
-const triggerTimers = ({event, meeting, data}) => {
-  switch (event) {
-    case eventType.CALL_INITIATED:
-      meeting.setStartCallInitJoinReq();
-      break;
-    case eventType.LOCUS_JOIN_REQUEST:
-      meeting.setEndCallInitJoinReq();
-      meeting.setStartJoinReqResp();
-      break;
-    case eventType.LOCUS_JOIN_RESPONSE:
-      meeting.setEndJoinReqResp();
-      meeting.setStartSetupDelay(mediaType.AUDIO);
-      meeting.setStartSetupDelay(mediaType.VIDEO);
-      meeting.setStartSendingMediaDelay(mediaType.AUDIO);
-      meeting.setStartSendingMediaDelay(mediaType.VIDEO);
-      break;
-    case eventType.RECEIVING_MEDIA_START:
-      meeting.setEndSetupDelay(data.mediaType);
-      break;
-    case eventType.SENDING_MEDIA_START:
-      meeting.setEndSendingMediaDelay(data.mediaType);
-      break;
-    case eventType.LOCAL_SDP_GENERATED:
-      meeting.setStartLocalSDPGenRemoteSDPRecvDelay();
-      break;
-    case eventType.REMOTE_SDP_RECEIVED:
-      meeting.setEndLocalSDPGenRemoteSDPRecvDelay();
-      break;
-    default:
-      break;
-  }
-};
 
 /**
  * @description Metrics handles all the call metrics events
@@ -69,10 +9,6 @@ const triggerTimers = ({event, meeting, data}) => {
  */
 class Metrics {
   static instance: Metrics;
-
-  _events: any;
-  keys: any;
-  meetingCollection: any;
   webex: any;
 
   /**
@@ -83,27 +19,6 @@ class Metrics {
    */
   constructor() {
     if (!Metrics.instance) {
-      /**
-       * @instance
-       * @type {Array}
-       * @private
-       * @memberof Metrics
-       */
-      this._events = [];
-      /**
-       * @instance
-       * @type {MeetingCollection}
-       * @private
-       * @memberof Metrics
-       */
-      this.meetingCollection = null;
-      /**
-       * @instance
-       * @type {MeetingCollection}
-       * @private
-       * @memberof Metrics
-       */
-      this.keys = Object.values(eventType);
       /**
        * @instance
        * @type {Metrics}
@@ -120,434 +35,14 @@ class Metrics {
   /**
    * Initializes the Metrics singleton with a meeting Collection.
    *
-   * @param {Object} meetingCollection meetings object
    * @param {Object} webex  webex SDK object
    *
    * @returns {void}
    */
-  initialSetup(meetingCollection: object, webex: object) {
-    this.meetingCollection = meetingCollection;
+  initialSetup(webex: object) {
     this.webex = webex;
   }
 
-  /**
-   * poste Meeting event metrics
-   * @param {object} options {meetingId/meeting} as a json object
-   * @param {Meeting} options.meeting Meeting object
-   * @param {String} options.meetingId
-   * @param {object} options.data
-   * @param {object} options.event
-   * @returns {object} null
-   */
-  postEvent(options: {meeting?: any; meetingId?: string; data?: object; event?: any} | any) {
-    const {meetingId, data = {}, event} = options;
-    let {meeting} = options;
-
-    if (this.keys.indexOf(event) === -1) {
-      LoggerProxy.logger.error(
-        `Metrics:index#postEvent --> Event ${event} doesn't exist in dictionary`
-      );
-    }
-
-    if (!meeting && meetingId) {
-      meeting = this.meetingCollection.get(meetingId);
-      options.meeting = meeting;
-    }
-
-    if (meeting) {
-      triggerTimers(options);
-
-      if (!meeting.callEvents) {
-        meeting.callEvents = [];
-      }
-      if (event === eventType.MEDIA_QUALITY) {
-        data.event = event;
-        meeting.sendMediaQualityAnalyzerMetrics(data);
-      } else {
-        meeting.callEvents.push(event);
-        data.event = event;
-        meeting.sendCallAnalyzerMetrics(data);
-      }
-    } else {
-      LoggerProxy.logger.info(
-        `Metrics:index#postEvent --> Event received for meetingId:${meetingId}, but meeting not found in collection.`
-      );
-    }
-  }
-
-  /**
-   *  Docs for Call analyzer metrics
-   *   https://sqbu-github.cisco.com/WebExSquared/call-analyzer/wiki
-   *   https://sqbu-github.cisco.com/WebExSquared/event-dictionary/blob/master/diagnostic-events.raml
-   */
-
-  // eslint-disable-next-line @typescript-eslint/no-shadow
-  initPayload(eventType, identifiers, options) {
-    const payload: any = {
-      eventId: uuid.v4(),
-      version: 1,
-      origin: {
-        name: 'endpoint',
-        networkType: 'unknown',
-        userAgent: this.userAgentToString(),
-        userType: options.userType,
-        loginType: options.loginType,
-        channel: options.channel,
-        clientInfo: {
-          clientType: options.clientType,
-          clientVersion: `${CLIENT_NAME}/${this.webex.version}`,
-          localNetworkPrefix: anonymizeIPAddress(this.webex.meetings.geoHintInfo?.clientAddress),
-          osVersion: getOSVersion() || 'unknown',
-          subClientType: options.subClientType,
-          os: getOSNameInternal(),
-          browser: getBrowserName(),
-          browserVersion: getBrowserVersion(),
-        },
-      },
-      originTime: {
-        triggered: new Date().toISOString(),
-      },
-      senderCountryCode: this.webex.meetings.geoHintInfo?.countryCode,
-      event: {
-        name: eventType,
-        canProceed: true,
-        identifiers,
-        eventData: {webClientDomain: window.location.hostname},
-      },
-    };
-
-    // TODO: more options should be checked and some of them should be mandatory in certain conditions
-    if (options) {
-      if (Object.prototype.hasOwnProperty.call(options, 'canProceed')) {
-        payload.event.canProceed = options.canProceed;
-      }
-      if (options.errors) {
-        payload.event.errors = options.errors;
-      }
-      if (options.mediaType) {
-        payload.event.mediaType = options.mediaType;
-      }
-      if (options.trigger) {
-        payload.event.trigger = options.trigger;
-      }
-      if (options.pstnAudioType) {
-        payload.event.pstnAudioType = options.pstnAudioType;
-      }
-      if (options.mediaCapabilities) {
-        payload.event.mediaCapabilities = options.mediaCapabilities;
-      }
-      if (options.recoveredBy) {
-        payload.event.recoveredBy = options.recoveredBy;
-      }
-      if (options.joinTimes) {
-        payload.event.joinTimes = options.joinTimes;
-      }
-      if (options.isRoapCallEnabled) {
-        payload.event.isRoapCallEnabled = options.isRoapCallEnabled;
-      }
-      ['breakoutMoveId', 'breakoutSessionId', 'breakoutGroupId'].forEach((item) => {
-        if (options[item]) {
-          payload.event.identifiers[item] = options[item];
-        }
-      });
-    }
-
-    return payload;
-  }
-
-  /**
-   * get the payload specific for a media quality event through call analyzer
-   * @param {String} eventType the event name
-   * @param {Object} identifiers contains the identifiers needed for CA
-   * @param {String} identifiers.correlationId
-   * @param {String} identifiers.locusUrl
-   * @param {String} identifiers.locusId
-   * @param {Object} options
-   * @param {Object} options.intervalData
-   * @param {String} options.clientType
-   * @returns {Object}
-   * @public
-   * @memberof Metrics
-   */
-  public initMediaPayload(
-    // eslint-disable-next-line @typescript-eslint/no-shadow
-    eventType: string,
-    identifiers: {
-      correlationId: string;
-      locusUrl: string;
-      locusId: string;
-    },
-    options:
-      | {
-          intervalData: object;
-          clientType: string;
-        }
-      | any = {}
-  ) {
-    const {audioSetupDelay, videoSetupDelay, joinTimes} = options;
-
-    const payload = {
-      eventId: uuid.v4(),
-      version: 1,
-      origin: {
-        audioSetupDelay,
-        videoSetupDelay,
-        name: 'endpoint',
-        networkType: options.networkType || UNKNOWN,
-        userAgent: this.userAgentToString(),
-        clientInfo: {
-          clientType: options.clientType, // TODO: Only clientType: 'TEAMS_CLIENT' is whitelisted
-          clientVersion: `${CLIENT_NAME}/${this.webex.version}`,
-          localNetworkPrefix: anonymizeIPAddress(this.webex.meetings.geoHintInfo?.clientAddress),
-          os: getOSNameInternal(),
-          osVersion: getOSVersion() || UNKNOWN,
-          subClientType: options.subClientType,
-          browser: getBrowserName(),
-          browserVersion: getBrowserVersion(),
-        },
-      },
-      originTime: {
-        triggered: new Date().toISOString(),
-      },
-      senderCountryCode: this.webex.meetings.geoHintInfo?.countryCode,
-      event: {
-        name: eventType,
-        canProceed: true,
-        identifiers,
-        intervals: [options.intervalData],
-        joinTimes,
-        eventData: {
-          webClientDomain: window.location.hostname,
-        },
-        sourceMetadata: {
-          applicationSoftwareType: CLIENT_NAME,
-          applicationSoftwareVersion: this.webex.version,
-          mediaEngineSoftwareType: getBrowserName() || 'browser',
-          mediaEngineSoftwareVersion: getOSVersion() || UNKNOWN,
-          startTime: new Date().toISOString(),
-        },
-      },
-    };
-
-    return payload;
-  }
-
-  /**
-   * This function Parses a Locus error and returns a diagnostic event payload.
-   * It should keep updating from:
-   * https://sqbu-github.cisco.com/WebExSquared/spark-client-framework/blob/master/spark-client-framework/Adapters/TelephonyAdapter/TelephonyAdapter.cpp#L920
-   *
-   * @param {Object} err the error Object from Locus response
-   * @param {boolean} showToUser true if a toast is shown to user
-   * @returns {{showToUser: boolean, category: string, errorDescription: string,
-   *  errorCode: number, errorData: *, fatal: boolean, name: string}}
-   */
-  parseLocusError(err: any, showToUser: boolean) {
-    let errorCode;
-
-    if (err && err.statusCode && err.statusCode >= 500) {
-      errorCode = 1003;
-    } else if (err && err.body && err.body.errorCode) {
-      // locus error codes: https://sqbu-github.cisco.com/WebExSquared/locus/blob/master/server/src/main/resources/locus-error-codes.properties
-      switch (ERROR_CODE[err.body.errorCode]) {
-        case MEETING_ERRORS.FREE_USER_MAX_PARTICIPANTS_EXCEEDED:
-          errorCode = 3007;
-          break;
-        case MEETING_ERRORS.PAID_USER_MAX_PARTICIPANTS_EXCEEDED:
-        case MEETING_ERRORS.SERVICE_MAX_PARTICIPANTS_EXCEEDED:
-          errorCode = 3002;
-          break;
-        case MEETING_ERRORS.INACTIVE:
-          errorCode = 4001;
-          break;
-        case MEETING_ERRORS.EXCEEDED_MAX_JOINED_PARTICIPANTS:
-        case MEETING_ERRORS.EXCEEDED_SERVICE_MAX_PARTICIPANTS:
-          errorCode = 3001;
-          break;
-        case MEETING_ERRORS.MEETING_IS_LOCKED:
-          errorCode = 4002;
-          break;
-        case MEETING_ERRORS.MEETING_IS_TERMINATING:
-          errorCode = 4003;
-          break;
-        case MEETING_ERRORS.MEETING_REQUIRE_MODERATOR_PIN_INTENT:
-          errorCode = 4004;
-          break;
-        case MEETING_ERRORS.MEETING_REQUIRE_MODERATOR_PIN:
-          errorCode = 4005;
-          break;
-        case MEETING_ERRORS.MEETING_REQUIRE_MODERATOR_ROLE:
-          errorCode = 4006;
-          break;
-        case MEETING_ERRORS.JOIN_RESTRICTED_USER:
-        case MEETING_ERRORS.GET_RESTRICTED_USER:
-        case MEETING_ERRORS.CREATE_MEDIA_RESTRICTED_USER:
-          errorCode = 3005;
-          break;
-        case MEETING_ERRORS.JOIN_RESTRICTED_USER_NOT_IN_ROOM:
-          errorCode = 4007;
-          break;
-        case MEETING_ERRORS.MEETING_NOT_FOUND:
-          errorCode = 4011;
-          break;
-        case MEETING_ERRORS.NOT_WEBEX_SITE:
-          errorCode = 4012;
-          break;
-        case MEETING_ERRORS.INVALID_JOIN_TIME:
-          errorCode = 4013;
-          break;
-        case MEETING_ERRORS.PHONE_NUMBER_NOT_A_NUMBER:
-          errorCode = 4016;
-          break;
-        case MEETING_ERRORS.PHONE_NUMBER_TOO_LONG:
-          errorCode = 4017;
-          break;
-        case MEETING_ERRORS.INVALID_DIALABLE_KEY:
-          errorCode = 4018;
-          break;
-        case MEETING_ERRORS.ONE_ON_ONE_TO_SELF_NOT_ALLOWED:
-          errorCode = 4019;
-          break;
-        case MEETING_ERRORS.REMOVED_PARTICIPANT:
-          errorCode = 4020;
-          break;
-        case MEETING_ERRORS.MEETING_LINK_NOT_FOUND:
-          errorCode = 4021;
-          break;
-        case MEETING_ERRORS.PHONE_NUMBER_TOO_SHORT_AFTER_IDD:
-          errorCode = 4022;
-          break;
-        case MEETING_ERRORS.INVALID_INVITEE_ADDRESS:
-          errorCode = 4023;
-          break;
-        case MEETING_ERRORS.PMR_ACCOUNT_LOCKED:
-          errorCode = 4024;
-          break;
-        case MEETING_ERRORS.RESOURCE_GUEST_FORBIDDEN:
-          errorCode = 4025;
-          break;
-        case MEETING_ERRORS.PMR_ACCOUNT_SUSPENDED:
-          errorCode = 4026;
-          break;
-        case MEETING_ERRORS.EMPTY_PHONE_NUMBER_OR_COUNTRY_CODE:
-          errorCode = 4027;
-          break;
-        case MEETING_ERRORS.INVALID_SINCE_OR_SEQUENCE_HASH_IN_REQUEST:
-          errorCode = 1006;
-          break;
-        case MEETING_ERRORS.CONVERSATION_NOT_FOUND:
-          errorCode = 4028;
-          break;
-        case MEETING_ERRORS.RECORDING_CONTROL_NOT_SUPPORTED:
-        case MEETING_ERRORS.RECORDING_NOT_STARTED:
-        case MEETING_ERRORS.RECORDING_NOT_ENABLED:
-          errorCode = 4029;
-          break;
-        default:
-          errorCode = 4008;
-      }
-    } else {
-      errorCode = 4008;
-    }
-
-    return this.generateErrorPayload(errorCode, showToUser, error.name.LOCUS_RESPONSE, err);
-  }
-
-  /**
-   * Pareses webex api error.
-   *
-   * @param {object} err
-   * @param {boolean} showToUser
-   * @returns {object | null}
-   */
-  parseWebexApiError(err: any, showToUser: boolean) {
-    const serviceErrorCode = err?.body?.code;
-    const clientCodeError = WebexAPIServiceErrorCodes[serviceErrorCode];
-
-    if (clientCodeError) {
-      return this.generateErrorPayload(clientCodeError, showToUser, error.name.OTHER, err);
-    }
-
-    return this.generateErrorPayload(4100, showToUser, error.name.OTHER, err);
-  }
-
-  /**
-   * Generates Error for the CA event
-   *
-   * @param {integer} errorCode
-   * @param {boolean} shownToUser
-   * @param {string} name
-   * @param {any} err
-   * @returns {any}
-   */
-  generateErrorPayload(errorCode, shownToUser, name, err) {
-    if (error.errors[errorCode]) {
-      const errorPayload: any = {
-        shownToUser: shownToUser || false,
-        category: error.errors[errorCode][2],
-        errorDescription: error.errors[errorCode][0],
-        errorCode,
-        fatal: !includes(error.notFatalErrorList, errorCode),
-        name: name || error.name.OTHER,
-        serviceErrorCode: err?.body?.code,
-      };
-
-      if (err && err.body) {
-        errorPayload.errorData = {error: err.body};
-      }
-
-      if (err && err.statusCode) {
-        errorPayload.httpCode = err.statusCode;
-      }
-
-      return errorPayload;
-    }
-
-    return null;
-  }
-
-  /**
-   * Returns a formated string of the user agent.
-   *
-   * @returns {string} formatted user agent information
-   */
-  userAgentToString() {
-    let userAgentOption;
-    let browserInfo;
-    const clientInfo = util.format('client=%s', `${this.webex.meetings?.metrics?.clientName}`);
-
-    if (
-      ['chrome', 'firefox', 'msie', 'msedge', 'safari'].indexOf(getBrowserName().toLowerCase()) !==
-      -1
-    ) {
-      browserInfo = util.format(
-        'browser=%s',
-        `${getBrowserName().toLowerCase()}/${getBrowserVersion().split('.')[0]}`
-      );
-    }
-    const osInfo = util.format('os=%s', `${getOSName()}/${getOSVersion().split('.')[0]}`);
-
-    if (browserInfo) {
-      userAgentOption = `(${browserInfo}`;
-    }
-    if (osInfo) {
-      userAgentOption = userAgentOption
-        ? `${userAgentOption}; ${clientInfo}; ${osInfo}`
-        : `${clientInfo}; (${osInfo}`;
-    }
-    if (userAgentOption) {
-      userAgentOption += ')';
-
-      return util.format(
-        'webex-js-sdk/%s %s',
-        `${process.env.NODE_ENV}-${this.webex.version}`,
-        userAgentOption
-      );
-    }
-
-    return util.format('webex-js-sdk/%s', `${process.env.NODE_ENV}-${this.webex.version}`);
-  }
-
   /**
    * Uploads given metric to the Metrics service as an Behavioral metric.
    * Metadata about the environment such as browser, OS, SDK and their versions

package/src/reconnection-manager/index.ts

@@ -18,7 +18,6 @@ import {
 import BEHAVIORAL_METRICS from '../metrics/constants';
 import ReconnectionError from '../common/errors/reconnection';
 import ReconnectInProgress from '../common/errors/reconnection-in-progress';
-import {eventType, reconnection, errorObjects} from '../metrics/config';
 import Metrics from '../metrics';
 import Meeting from '../meeting';
 import {MediaRequestManager} from '../multistream/mediaRequestManager';
@@ -325,9 +324,13 @@ export default class ReconnectionManager {
       LoggerProxy.logger.info(
         'ReconnectionManager:index#reconnect --> Sending reconnect start metric.'
       );
-      Metrics.postEvent({
-        event: eventType.MEDIA_RECONNECTING,
-        meeting: this.meeting,
+
+      // @ts-ignore
+      this.webex.internal.newMetrics.submitClientEvent({
+        name: 'client.media.reconnecting',
+        options: {
+          meetingId: this.meeting.id,
+        },
       });
     }
 
@@ -337,10 +340,16 @@ export default class ReconnectionManager {
         LoggerProxy.logger.info(
           'ReconnectionManager:index#reconnect --> Sending reconnect success metric.'
         );
-        Metrics.postEvent({
-          event: eventType.MEDIA_RECOVERED,
-          meeting: this.meeting,
-          data: {recoveredBy: reconnection.RECOVERED_BY_NEW},
+
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.media.recovered',
+          payload: {
+            recoveredBy: 'new',
+          },
+          options: {
+            meetingId: this.meeting.id,
+          },
         });
       })
       .catch((reconnectError) => {
@@ -364,23 +373,24 @@ export default class ReconnectionManager {
           'ReconnectionManager:index#reconnect --> Sending reconnect abort metric.'
         );
 
-        const reconnectMetric = {
-          event: eventType.CALL_ABORTED,
-          meeting: this.meeting,
-          data: {
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.call.aborted',
+          payload: {
             errors: [
               {
-                category: errorObjects.category.expected,
+                category: 'expected',
                 errorCode: 2008,
                 fatal: true,
-                name: errorObjects.name.mediaEngine,
+                name: 'media-engine',
                 shownToUser: false,
               },
             ],
           },
-        };
-
-        Metrics.postEvent(reconnectMetric);
+          options: {
+            meetingId: this.meeting.id,
+          },
+        });
         if (reconnectError instanceof NeedsRejoinError) {
           // send call aborded event with catogery as expected as we are trying to rejoin
 

package/src/roap/request.ts

@@ -3,8 +3,6 @@ import {StatelessWebexPlugin} from '@webex/webex-core';
 
 import LoggerProxy from '../common/logs/logger-proxy';
 import {REACHABILITY} from '../constants';
-import Metrics from '../metrics';
-import {eventType} from '../metrics/config';
 import {LocusMediaRequest} from '../meeting/locusMediaRequest';
 
 /**
@@ -95,7 +93,13 @@ export default class RoapRequest extends StatelessWebexPlugin {
       `Roap:request#sendRoap --> ${locusSelfUrl} \n ${roapMessage.messageType} \n seq:${roapMessage.seq}`
     );
 
-    Metrics.postEvent({event: eventType.MEDIA_REQUEST, meetingId});
+    // @ts-ignore
+    this.webex.internal.newMetrics.submitClientEvent({
+      name: 'client.locus.media.request',
+      options: {
+        meetingId,
+      },
+    });
 
     return locusMediaRequest
       .send({
@@ -107,8 +111,13 @@ export default class RoapRequest extends StatelessWebexPlugin {
         reachability: localSdpWithReachabilityData.reachability,
       })
       .then((res) => {
-        Metrics.postEvent({event: eventType.MEDIA_RESPONSE, meetingId});
-
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.locus.media.response',
+          options: {
+            meetingId,
+          },
+        });
         // always it will be the first mediaConnection Object
         const mediaConnections =
           res.body.mediaConnections &&
@@ -132,10 +141,13 @@ export default class RoapRequest extends StatelessWebexPlugin {
         };
       })
       .catch((err) => {
-        Metrics.postEvent({
-          event: eventType.MEDIA_RESPONSE,
-          meetingId,
-          data: {error: Metrics.parseLocusError(err, true)},
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.locus.media.response',
+          options: {
+            meetingId,
+            rawError: err,
+          },
         });
         LoggerProxy.logger.error(`Roap:request#sendRoap --> Error:${JSON.stringify(err, null, 2)}`);
         LoggerProxy.logger.error(

package/test/unit/spec/breakouts/breakout.ts

@@ -93,10 +93,12 @@ describe('plugin-meetings', () => {
         let onBreakoutMoveResponseStub = sinon.stub(breakoutEvent, 'onBreakoutMoveResponse');
         await breakout.join();
         assert.calledOnceWithExactly(breakoutEvent.onBreakoutMoveRequest,
-          {currentSession: breakout, meeting: {id: 'meeting-id'}, breakoutMoveId: 'breakoutMoveId'}
+          {currentSession: breakout, meeting: {id: 'meeting-id'}, breakoutMoveId: 'breakoutMoveId'},
+          webex.internal.newMetrics.submitClientEvent
         );
         assert.calledOnceWithExactly(breakoutEvent.onBreakoutMoveResponse,
-          {currentSession: breakout, meeting: {id: 'meeting-id'}, breakoutMoveId: 'breakoutMoveId'}
+          {currentSession: breakout, meeting: {id: 'meeting-id'}, breakoutMoveId: 'breakoutMoveId'},
+          webex.internal.newMetrics.submitClientEvent
         );
 
         onBreakoutMoveRequestStub.restore();