@webex/plugin-meetings 3.0.0-stream-classes.5 → 3.0.0

package/src/roap/turnDiscovery.ts

@@ -56,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'
@@ -88,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'},
@@ -129,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
    *
@@ -168,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(
@@ -186,10 +215,41 @@ export default class TurnDiscovery {
         // @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;
       });
   }
 
@@ -225,10 +285,11 @@ export default class TurnDiscovery {
    * @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> {
-    // @ts-ignore - fix type
-    const isAnyClusterReachable = await meeting.webex.meetings.reachability.isAnyClusterReachable();
+    const isAnyPublicClusterReachable =
+      // @ts-ignore - fix type
+      await meeting.webex.meetings.reachability.isAnyPublicClusterReachable();
 
-    if (isAnyClusterReachable) {
+    if (isAnyPublicClusterReachable) {
       LoggerProxy.logger.info(
         'Roap:turnDiscovery#getSkipReason --> reachability has not failed, skipping TURN discovery'
       );
@@ -236,15 +297,6 @@ export default class TurnDiscovery {
       return 'reachability';
     }
 
-    // @ts-ignore - fix type
-    if (!meeting.config.experimental.enableTurnDiscovery) {
-      LoggerProxy.logger.info(
-        'Roap:turnDiscovery#getSkipReason --> TURN discovery disabled in config, skipping it'
-      );
-
-      return 'config';
-    }
-
     return '';
   }
 
@@ -273,12 +325,17 @@ 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) {
-    const turnDiscoverySkippedReason = await this.getSkipReason(meeting);
+  async doTurnDiscovery(meeting: Meeting, isReconnecting?: boolean, isForced?: boolean) {
+    let turnDiscoverySkippedReason: string;
+
+    if (!isForced) {
+      turnDiscoverySkippedReason = await this.getSkipReason(meeting);
+    }
 
     if (turnDiscoverySkippedReason) {
       return {
@@ -287,30 +344,46 @@ export default class TurnDiscovery {
       };
     }
 
-    return this.sendRoapTurnDiscoveryRequest(meeting, isReconnecting)
-      .then(() => this.waitForTurnDiscoveryResponse())
-      .then(() => this.sendRoapOK(meeting))
-      .then(() => {
-        this.defer = undefined;
+    try {
+      const httpResponse = await this.sendRoapTurnDiscoveryRequest(meeting, isReconnecting);
 
-        LoggerProxy.logger.info('Roap:turnDiscovery#doTurnDiscovery --> TURN discovery completed');
+      // 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();
+
+      if (isOkRequired) {
+        await this.sendRoapOK(meeting);
 
-        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/index.ts

@@ -1,5 +1,20 @@
+/* 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
  */
@@ -17,6 +32,8 @@ export default class RtcMetrics {
 
   correlationId: string;
 
+  connectionId: string;
+
   /**
    * Initialize the interval.
    *
@@ -26,12 +43,13 @@ export default class RtcMetrics {
    */
   constructor(webex, meetingId, correlationId) {
     // `window` is used to prevent typescript from returning a NodeJS.Timer.
-    this.intervalId = window.setInterval(this.checkMetrics.bind(this), 30 * 1000);
+    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.checkMetrics.bind(this), 5 * 1000);
+    setTimeout(this.sendMetricsInQueue.bind(this), 5 * 1000);
   }
 
   /**
@@ -39,7 +57,7 @@ export default class RtcMetrics {
    *
    * @returns {void}
    */
-  private checkMetrics() {
+  public sendMetricsInQueue() {
     if (this.metricsQueue.length) {
       this.sendMetrics();
       this.metricsQueue = [];
@@ -55,7 +73,26 @@ export default class RtcMetrics {
    */
   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);
+      }
     }
   }
 
@@ -65,10 +102,38 @@ export default class RtcMetrics {
    * @returns {void}
    */
   closeMetrics() {
-    this.checkMetrics();
+    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.
    *
@@ -87,10 +152,11 @@ export default class RtcMetrics {
         metrics: [
           {
             type: 'webrtc',
-            version: '1.0.1',
+            version: '1.1.0',
             userId: this.webex.internal.device.userId,
             meetingId: this.meetingId,
             correlationId: this.correlationId,
+            connectionId: this.connectionId,
             data: this.metricsQueue,
           },
         ],