@webex/plugin-meetings 3.0.0-beta.39 → 3.0.0-beta.391

package/src/roap/request.ts

@@ -1,11 +1,9 @@
-/* global window */
 // @ts-ignore
 import {StatelessWebexPlugin} from '@webex/webex-core';
 
 import LoggerProxy from '../common/logs/logger-proxy';
-import {MEDIA, HTTP_VERBS, REACHABILITY} from '../constants';
-import Metrics from '../metrics';
-import {eventType} from '../metrics/config';
+import {IP_VERSION, REACHABILITY} from '../constants';
+import {LocusMediaRequest} from '../meeting/locusMediaRequest';
 
 /**
  * @class RoapRequest
@@ -20,23 +18,10 @@ export default class RoapRequest extends StatelessWebexPlugin {
     let joinCookie;
 
     // @ts-ignore
-    const reachabilityData = await this.webex.boundedStorage
-      .get(REACHABILITY.namespace, REACHABILITY.localStorageResult)
-      .catch(() => {});
-
-    if (reachabilityData) {
-      try {
-        const reachabilityResult = JSON.parse(reachabilityData);
+    const reachabilityResult = await this.webex.meetings.reachability.getReachabilityResults();
 
-        /* istanbul ignore else */
-        if (reachabilityResult && Object.keys(reachabilityResult).length) {
-          localSdp.reachability = reachabilityResult;
-        }
-      } catch (e) {
-        LoggerProxy.logger.error(
-          `Roap:request#attachReachabilityData --> Error in parsing reachability data: ${e}`
-        );
-      }
+    if (reachabilityResult && Object.keys(reachabilityResult).length) {
+      localSdp.reachability = reachabilityResult;
     }
 
     // @ts-ignore
@@ -64,72 +49,65 @@ export default class RoapRequest extends StatelessWebexPlugin {
    * @param {String} options.locusSelfUrl
    * @param {String} options.mediaId
    * @param {String} options.correlationId
-   * @param {Boolean} options.audioMuted
-   * @param {Boolean} options.videoMuted
    * @param {String} options.meetingId
-   * @param {Boolean} options.preferTranscoding
+   * @param {IP_VERSION} options.ipVersion only required for offers
    * @returns {Promise} returns the response/failure of the request
    */
   async sendRoap(options: {
     roapMessage: any;
     locusSelfUrl: string;
     mediaId: string;
-    correlationId: string;
-    audioMuted: boolean;
-    videoMuted: boolean;
     meetingId: string;
-    preferTranscoding?: boolean;
+    ipVersion?: IP_VERSION;
+    locusMediaRequest?: LocusMediaRequest;
   }) {
-    const {roapMessage, locusSelfUrl, mediaId, correlationId, meetingId} = options;
+    const {roapMessage, locusSelfUrl, mediaId, meetingId, locusMediaRequest, ipVersion} = options;
 
     if (!mediaId) {
-      LoggerProxy.logger.info('Roap:request#sendRoap --> Race Condition /call mediaID not present');
+      LoggerProxy.logger.info('Roap:request#sendRoap --> sending empty mediaID');
     }
 
+    if (!locusMediaRequest) {
+      LoggerProxy.logger.warn(
+        'Roap:request#sendRoap --> locusMediaRequest unavailable, not sending roap'
+      );
+
+      return Promise.reject(new Error('sendRoap called when locusMediaRequest is undefined'));
+    }
     const {localSdp: localSdpWithReachabilityData, joinCookie} = await this.attachReachabilityData({
       roapMessage,
-      // eslint-disable-next-line no-warning-comments
-      // TODO: check whats the need for video and audiomute
-      audioMuted: !!options.audioMuted,
-      videoMuted: !!options.videoMuted,
     });
 
-    const mediaUrl = `${locusSelfUrl}/${MEDIA}`;
-    // @ts-ignore
-    const deviceUrl = this.webex.internal.device.url;
-
     LoggerProxy.logger.info(
-      `Roap:request#sendRoap --> ${mediaUrl} \n ${roapMessage.messageType} \n seq:${roapMessage.seq}`
+      `Roap:request#sendRoap --> ${locusSelfUrl} \n ${roapMessage.messageType} \n seq:${roapMessage.seq}`
     );
 
-    Metrics.postEvent({event: eventType.MEDIA_REQUEST, meetingId});
-
     // @ts-ignore
-    return this.request({
-      uri: mediaUrl,
-      method: HTTP_VERBS.PUT,
-      body: {
-        device: {
-          url: deviceUrl,
-          // @ts-ignore
-          deviceType: this.config.meetings.deviceType,
-        },
-        correlationId,
-        localMedias: [
-          {
-            localSdp: JSON.stringify(localSdpWithReachabilityData),
-            mediaId: options.mediaId,
-          },
-        ],
-        clientMediaPreferences: {
-          preferTranscoding: options.preferTranscoding ?? true,
-          joinCookie,
-        },
+    this.webex.internal.newMetrics.submitClientEvent({
+      name: 'client.locus.media.request',
+      options: {
+        meetingId,
       },
-    })
-      .then((res) => {
-        Metrics.postEvent({event: eventType.MEDIA_RESPONSE, meetingId});
+    });
 
+    return locusMediaRequest
+      .send({
+        type: 'RoapMessage',
+        selfUrl: locusSelfUrl,
+        joinCookie,
+        mediaId,
+        roapMessage,
+        reachability: localSdpWithReachabilityData.reachability,
+        ipVersion,
+      })
+      .then((res) => {
+        // @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 &&
@@ -153,10 +131,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/src/roap/turnDiscovery.ts

@@ -8,6 +8,7 @@ import {ROAP} from '../constants';
 
 import RoapRequest from './request';
 import Meeting from '../meeting';
+import MeetingUtil from '../meeting/util';
 
 const TURN_DISCOVERY_TIMEOUT = 10; // in seconds
 
@@ -55,7 +56,7 @@ export default class TurnDiscovery {
    * @private
    * @memberof Roap
    */
-  private waitForTurnDiscoveryResponse() {
+  private waitForTurnDiscoveryResponse(): Promise<{isOkRequired: boolean}> {
     if (!this.defer) {
       LoggerProxy.logger.warn(
         'Roap:turnDiscovery#waitForTurnDiscoveryResponse --> TURN discovery is not in progress'
@@ -87,22 +88,32 @@ export default class TurnDiscovery {
    * handles TURN_DISCOVERY_RESPONSE roap message
    *
    * @param {Object} roapMessage
+   * @param {string} from string to indicate how we got the response (used just for logging)
    * @returns {void}
    * @public
    * @memberof Roap
    */
-  public handleTurnDiscoveryResponse(roapMessage: object) {
-    // @ts-ignore - Fix missing type
+  public handleTurnDiscoveryResponse(roapMessage: any, from: string) {
     const {headers} = roapMessage;
 
     if (!this.defer) {
       LoggerProxy.logger.warn(
-        'Roap:turnDiscovery#handleTurnDiscoveryResponse --> unexpected TURN discovery response'
+        `Roap:turnDiscovery#handleTurnDiscoveryResponse --> unexpected TURN discovery response ${from}`
       );
 
       return;
     }
 
+    if (roapMessage.messageType !== ROAP.ROAP_TYPES.TURN_DISCOVERY_RESPONSE) {
+      this.defer.reject(
+        new Error(
+          `TURN_DISCOVERY_RESPONSE ${from} has unexpected messageType: ${JSON.stringify(
+            roapMessage
+          )}`
+        )
+      );
+    }
+
     const expectedHeaders = [
       {headerName: 'x-cisco-turn-url', field: 'url'},
       {headerName: 'x-cisco-turn-username', field: 'username'},
@@ -128,21 +139,39 @@ export default class TurnDiscovery {
 
     if (foundHeaders !== expectedHeaders.length) {
       LoggerProxy.logger.warn(
-        `Roap:turnDiscovery#handleTurnDiscoveryResponse --> missing some headers, received: ${JSON.stringify(
+        `Roap:turnDiscovery#handleTurnDiscoveryResponse --> missing some headers, received ${from}: ${JSON.stringify(
           headers
         )}`
       );
       this.defer.reject(
-        new Error(`TURN_DISCOVERY_RESPONSE missing some headers: ${JSON.stringify(headers)}`)
+        new Error(
+          `TURN_DISCOVERY_RESPONSE ${from} missing some headers: ${JSON.stringify(headers)}`
+        )
       );
     } else {
       LoggerProxy.logger.info(
-        `Roap:turnDiscovery#handleTurnDiscoveryResponse --> received a valid response, url=${this.turnInfo.url}`
+        `Roap:turnDiscovery#handleTurnDiscoveryResponse --> received a valid response ${from}, url=${this.turnInfo.url}`
       );
-      this.defer.resolve();
+
+      this.defer.resolve({isOkRequired: !headers?.includes('noOkInTransaction')});
     }
   }
 
+  /**
+   * handles TURN_DISCOVERY_RESPONSE roap message that came in http response
+   *
+   * @param {Object} roapMessage
+   * @returns {Promise}
+   * @memberof Roap
+   */
+  private async handleTurnDiscoveryResponseInHttpResponse(
+    roapMessage: object
+  ): Promise<{isOkRequired: boolean}> {
+    this.handleTurnDiscoveryResponse(roapMessage, 'in http response');
+
+    return this.defer.promise;
+  }
+
   /**
    * sends the TURN_DISCOVERY_REQUEST roap request
    *
@@ -167,6 +196,7 @@ export default class TurnDiscovery {
       messageType: ROAP.ROAP_TYPES.TURN_DISCOVERY_REQUEST,
       version: ROAP.ROAP_VERSION,
       seq: TURN_DISCOVERY_SEQ,
+      headers: ['includeAnswerInHttpResponse', 'noOkInTransaction'],
     };
 
     LoggerProxy.logger.info(
@@ -176,20 +206,50 @@ export default class TurnDiscovery {
     return this.roapRequest
       .sendRoap({
         roapMessage,
-        correlationId: meeting.correlationId,
         // @ts-ignore - Fix missing type
         locusSelfUrl: meeting.selfUrl,
         // @ts-ignore - Fix missing type
         mediaId: isReconnecting ? '' : meeting.mediaId,
-        audioMuted: meeting.audio?.isLocallyMuted(),
-        videoMuted: meeting.video?.isLocallyMuted(),
         meetingId: meeting.id,
-        preferTranscoding: !meeting.isMultistream,
+        locusMediaRequest: meeting.locusMediaRequest,
+        // @ts-ignore - because of meeting.webex
+        ipVersion: MeetingUtil.getIpVersion(meeting.webex),
       })
-      .then(({mediaConnections}) => {
+      .then((response) => {
+        const {mediaConnections} = response;
+
+        let turnDiscoveryResponse;
+
         if (mediaConnections) {
           meeting.updateMediaConnections(mediaConnections);
+
+          if (mediaConnections[0]?.remoteSdp) {
+            const remoteSdp = JSON.parse(mediaConnections[0].remoteSdp);
+
+            if (remoteSdp.roapMessage) {
+              // yes, it's misleading that remoteSdp actually contains a TURN discovery response, but that's how the backend works...
+              const {seq, messageType, errorType, errorCause, headers} = remoteSdp.roapMessage;
+
+              turnDiscoveryResponse = {
+                seq,
+                messageType,
+                errorType,
+                errorCause,
+                headers,
+              };
+            }
+          }
         }
+
+        if (!turnDiscoveryResponse) {
+          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ROAP_HTTP_RESPONSE_MISSING, {
+            correlationId: meeting.correlationId,
+            messageType: 'TURN_DISCOVERY_RESPONSE',
+            isMultistream: meeting.isMultistream,
+          });
+        }
+
+        return turnDiscoveryResponse;
       });
   }
 
@@ -213,14 +273,45 @@ export default class TurnDiscovery {
       locusSelfUrl: meeting.selfUrl,
       // @ts-ignore - fix type
       mediaId: meeting.mediaId,
-      correlationId: meeting.correlationId,
-      audioMuted: meeting.audio?.isLocallyMuted(),
-      videoMuted: meeting.video?.isLocallyMuted(),
       meetingId: meeting.id,
-      preferTranscoding: !meeting.isMultistream,
+      locusMediaRequest: meeting.locusMediaRequest,
     });
   }
 
+  /**
+   * Gets the reason why reachability is skipped.
+   *
+   * @param {Meeting} meeting
+   * @returns {Promise<string>} Promise with empty string if reachability is not skipped or a reason if it is skipped
+   */
+  private async getSkipReason(meeting: Meeting): Promise<string> {
+    const isAnyPublicClusterReachable =
+      // @ts-ignore - fix type
+      await meeting.webex.meetings.reachability.isAnyPublicClusterReachable();
+
+    if (isAnyPublicClusterReachable) {
+      LoggerProxy.logger.info(
+        'Roap:turnDiscovery#getSkipReason --> reachability has not failed, skipping TURN discovery'
+      );
+
+      return 'reachability';
+    }
+
+    return '';
+  }
+
+  /**
+   * Checks if TURN discovery is skipped.
+   *
+   * @param {Meeting} meeting
+   * @returns {Boolean} true if TURN discovery is being skipped, false if it is being done
+   */
+  async isSkipped(meeting) {
+    const skipReason = await this.getSkipReason(meeting);
+
+    return !!skipReason;
+  }
+
   /**
    * Retrieves TURN server information from the backend by doing
    * a roap message exchange:
@@ -234,58 +325,65 @@ export default class TurnDiscovery {
    * so it works fine no matter if TURN discovery is done or not.
    *
    * @param {Meeting} meeting
-   * @param {Boolean} isReconnecting should be set to true if this is a new
+   * @param {Boolean} [isReconnecting] should be set to true if this is a new
    *                                 media connection just after a reconnection
+   * @param {Boolean} [isForced]
    * @returns {Promise}
    */
-  async doTurnDiscovery(meeting: Meeting, isReconnecting?: boolean) {
-    // @ts-ignore - fix type
-    const isAnyClusterReachable = await meeting.webex.meetings.reachability.isAnyClusterReachable();
+  async doTurnDiscovery(meeting: Meeting, isReconnecting?: boolean, isForced?: boolean) {
+    let turnDiscoverySkippedReason: string;
 
-    if (isAnyClusterReachable) {
-      LoggerProxy.logger.info(
-        'Roap:turnDiscovery#doTurnDiscovery --> reachability has not failed, skipping TURN discovery'
-      );
+    if (!isForced) {
+      turnDiscoverySkippedReason = await this.getSkipReason(meeting);
+    }
 
+    if (turnDiscoverySkippedReason) {
       return {
         turnServerInfo: undefined,
-        turnDiscoverySkippedReason: 'reachability',
+        turnDiscoverySkippedReason,
       };
     }
 
-    // @ts-ignore - fix type
-    if (!meeting.config.experimental.enableTurnDiscovery) {
-      LoggerProxy.logger.info(
-        'Roap:turnDiscovery#doTurnDiscovery --> TURN discovery disabled in config, skipping it'
-      );
+    try {
+      const httpResponse = await this.sendRoapTurnDiscoveryRequest(meeting, isReconnecting);
 
-      return {turnServerInfo: undefined, turnDiscoverySkippedReason: 'config'};
-    }
+      // if we haven't got the response over http, we need to wait for it to come over the websocket via Mercury
+      const {isOkRequired} = httpResponse
+        ? await this.handleTurnDiscoveryResponseInHttpResponse(httpResponse)
+        : await this.waitForTurnDiscoveryResponse();
 
-    return this.sendRoapTurnDiscoveryRequest(meeting, isReconnecting)
-      .then(() => this.waitForTurnDiscoveryResponse())
-      .then(() => this.sendRoapOK(meeting))
-      .then(() => {
-        this.defer = undefined;
+      if (isOkRequired) {
+        await this.sendRoapOK(meeting);
 
-        LoggerProxy.logger.info('Roap:turnDiscovery#doTurnDiscovery --> TURN discovery completed');
-
-        return {turnServerInfo: this.turnInfo, turnDiscoverySkippedReason: undefined};
-      })
-      .catch((e) => {
-        // we catch any errors and resolve with no turn information so that the normal call join flow can continue without TURN
         LoggerProxy.logger.info(
-          `Roap:turnDiscovery#doTurnDiscovery --> TURN discovery failed, continuing without TURN: ${e}`
+          'Roap:turnDiscovery#doTurnDiscovery --> TURN discovery response requires OK'
         );
 
-        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.TURN_DISCOVERY_FAILURE, {
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.TURN_DISCOVERY_REQUIRES_OK, {
           correlation_id: meeting.correlationId,
           locus_id: meeting.locusUrl.split('/').pop(),
-          reason: e.message,
-          stack: e.stack,
         });
+      }
+
+      this.defer = undefined;
 
-        return {turnServerInfo: undefined, turnDiscoverySkippedReason: undefined};
+      LoggerProxy.logger.info('Roap:turnDiscovery#doTurnDiscovery --> TURN discovery completed');
+
+      return {turnServerInfo: this.turnInfo, turnDiscoverySkippedReason: undefined};
+    } catch (e) {
+      // we catch any errors and resolve with no turn information so that the normal call join flow can continue without TURN
+      LoggerProxy.logger.info(
+        `Roap:turnDiscovery#doTurnDiscovery --> TURN discovery failed, continuing without TURN: ${e}`
+      );
+
+      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.TURN_DISCOVERY_FAILURE, {
+        correlation_id: meeting.correlationId,
+        locus_id: meeting.locusUrl.split('/').pop(),
+        reason: e.message,
+        stack: e.stack,
       });
+
+      return {turnServerInfo: undefined, turnDiscoverySkippedReason: undefined};
+    }
   }
 }

package/src/rtcMetrics/constants.ts

@@ -0,0 +1,3 @@
+const RTC_METRICS = {APP_ID: 'FFB51ED5-4319-4C55-8303-B1F2FCCDE231'};
+
+export {RTC_METRICS as default};

package/src/rtcMetrics/index.ts

@@ -0,0 +1,166 @@
+/* eslint-disable class-methods-use-this */
+import {CallDiagnosticUtils} from '@webex/internal-plugin-metrics';
+import uuid from 'uuid';
+import RTC_METRICS from './constants';
+
+const parseJsonPayload = (payload: any[]): any | null => {
+  try {
+    if (payload && payload[0]) {
+      return JSON.parse(payload[0]);
+    }
+
+    return null;
+  } catch (_) {
+    return null;
+  }
+};
+
+/**
+ * Rtc Metrics
+ */
+export default class RtcMetrics {
+  /**
+   * Array of MetricData items to be sent to the metrics service.
+   */
+  metricsQueue = [];
+
+  intervalId: number;
+
+  webex: any;
+
+  meetingId: string;
+
+  correlationId: string;
+
+  connectionId: string;
+
+  /**
+   * Initialize the interval.
+   *
+   * @param {object} webex - The main `webex` object.
+   * @param {string} meetingId - The meeting id.
+   * @param {string} correlationId - The correlation id.
+   */
+  constructor(webex, meetingId, correlationId) {
+    // `window` is used to prevent typescript from returning a NodeJS.Timer.
+    this.intervalId = window.setInterval(this.sendMetricsInQueue.bind(this), 30 * 1000);
+    this.meetingId = meetingId;
+    this.webex = webex;
+    this.correlationId = correlationId;
+    this.setNewConnectionId();
+    // Send the first set of metrics at 5 seconds in the case of a user leaving the call shortly after joining.
+    setTimeout(this.sendMetricsInQueue.bind(this), 5 * 1000);
+  }
+
+  /**
+   * Check to see if the metrics queue has any items.
+   *
+   * @returns {void}
+   */
+  public sendMetricsInQueue() {
+    if (this.metricsQueue.length) {
+      this.sendMetrics();
+      this.metricsQueue = [];
+    }
+  }
+
+  /**
+   * Add metrics items to the metrics queue.
+   *
+   * @param {object} data - An object with a payload array of metrics items.
+   *
+   * @returns {void}
+   */
+  addMetrics(data) {
+    if (data.payload.length) {
+      if (data.name === 'stats-report') {
+        data.payload = data.payload.map(this.anonymizeIp);
+      }
+
+      this.metricsQueue.push(data);
+
+      try {
+        // If a connection fails, send the rest of the metrics in queue and get a new connection id.
+        const parsedPayload = parseJsonPayload(data.payload);
+        if (
+          data.name === 'onconnectionstatechange' &&
+          parsedPayload &&
+          parsedPayload.value === 'failed'
+        ) {
+          this.sendMetricsInQueue();
+          this.setNewConnectionId();
+        }
+      } catch (e) {
+        console.error(e);
+      }
+    }
+  }
+
+  /**
+   * Clear the metrics interval.
+   *
+   * @returns {void}
+   */
+  closeMetrics() {
+    this.sendMetricsInQueue();
+    clearInterval(this.intervalId);
+  }
+
+  /**
+   * Anonymize IP addresses.
+   *
+   * @param {array} stats - An RTCStatsReport organized into an array of strings.
+   * @returns {string}
+   */
+  anonymizeIp(stats: string): string {
+    const data = JSON.parse(stats);
+    // on local and remote candidates, anonymize the last 4 bits.
+    if (data.type === 'local-candidate' || data.type === 'remote-candidate') {
+      data.ip = CallDiagnosticUtils.anonymizeIPAddress(data.ip) || undefined;
+      data.address = CallDiagnosticUtils.anonymizeIPAddress(data.address) || undefined;
+      data.relatedAddress =
+        CallDiagnosticUtils.anonymizeIPAddress(data.relatedAddress) || undefined;
+    }
+
+    return JSON.stringify(data);
+  }
+
+  /**
+   * Set a new connection id.
+   *
+   * @returns {void}
+   */
+  private setNewConnectionId() {
+    this.connectionId = uuid.v4();
+  }
+
+  /**
+   * Send metrics to the metrics service.
+   *
+   * @returns {void}
+   */
+  private sendMetrics() {
+    this.webex.request({
+      method: 'POST',
+      service: 'unifiedTelemetry',
+      resource: 'metric/v2',
+      headers: {
+        type: 'webrtcMedia',
+        appId: RTC_METRICS.APP_ID,
+      },
+      body: {
+        metrics: [
+          {
+            type: 'webrtc',
+            version: '1.1.0',
+            userId: this.webex.internal.device.userId,
+            meetingId: this.meetingId,
+            correlationId: this.correlationId,
+            connectionId: this.connectionId,
+            data: this.metricsQueue,
+          },
+        ],
+      },
+    });
+  }
+}