@webex/plugin-meetings 2.60.1-next.13 → 2.60.1-next.14

package/src/reachability/index.ts

@@ -95,12 +95,6 @@ export default class Reachability {
    * @memberof Reachability
    */
   public async gatherReachability(): Promise<ReachabilityResults> {
-    // Remove stored reachability results to ensure no stale data
-    // @ts-ignore
-    await this.webex.boundedStorage.del(this.namespace, REACHABILITY.localStorageResult);
-    // @ts-ignore
-    await this.webex.boundedStorage.del(this.namespace, REACHABILITY.localStorageJoinCookie);
-
     // Fetch clusters and measure latency
     try {
       const {clusters, joinCookie} = await this.reachabilityRequest.getClusters(

package/src/reconnection-manager/index.ts

@@ -349,7 +349,20 @@ export default class ReconnectionManager {
       });
     }
 
-    return this.executeReconnection({networkDisconnect}).catch((reconnectError) => {
+    try {
+      await this.webex.meetings.startReachability();
+    } catch (err) {
+      LoggerProxy.logger.info(
+        'ReconnectionManager:index#reconnect --> Reachability failed, continuing with reconnection attempt, err: ',
+        err
+      );
+    }
+
+    try {
+      const media = await this.executeReconnection({networkDisconnect});
+
+      return media;
+    } catch (reconnectError) {
       if (reconnectError instanceof NeedsRetryError) {
         LoggerProxy.logger.info(
           'ReconnectionManager:index#reconnect --> Reconnection not successful, retrying.'
@@ -370,6 +383,7 @@ export default class ReconnectionManager {
         'ReconnectionManager:index#reconnect --> Sending reconnect abort metric.'
       );
 
+      // send call aborted event with catogery as expected as we are trying to rejoin
       // @ts-ignore
       this.webex.internal.newMetrics.submitClientEvent({
         name: 'client.call.aborted',
@@ -388,16 +402,13 @@ export default class ReconnectionManager {
           meetingId: this.meeting.id,
         },
       });
-      if (reconnectError instanceof NeedsRejoinError) {
-        // send call aborded event with catogery as expected as we are trying to rejoin
 
-        if (this.autoRejoinEnabled) {
-          return this.rejoinMeeting(reconnectError.wasSharing);
-        }
+      if (reconnectError instanceof NeedsRejoinError && this.autoRejoinEnabled) {
+        return this.rejoinMeeting(reconnectError.wasSharing);
       }
 
       throw reconnectError;
-    });
+    }
   }
 
   /**

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;
       });
   }
 
@@ -284,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,
         });
+      }
 
-        return {turnServerInfo: undefined, turnDiscoverySkippedReason: undefined};
+      this.defer = 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,7 +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
  */
@@ -19,6 +32,8 @@ export default class RtcMetrics {
 
   correlationId: string;
 
+  connectionId: string;
+
   /**
    * Initialize the interval.
    *
@@ -32,6 +47,7 @@ export default class RtcMetrics {
     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);
   }
@@ -60,7 +76,23 @@ export default class RtcMetrics {
       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);
+      }
     }
   }
 
@@ -93,6 +125,15 @@ export default class RtcMetrics {
     return JSON.stringify(data);
   }
 
+  /**
+   * Set a new connection id.
+   *
+   * @returns {void}
+   */
+  private setNewConnectionId() {
+    this.connectionId = uuid.v4();
+  }
+
   /**
    * Send metrics to the metrics service.
    *
@@ -111,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,
           },
         ],

package/src/statsAnalyzer/index.ts

@@ -18,6 +18,10 @@ import {
   emptyMqaInterval,
   emptyVideoReceive,
   emptyVideoTransmit,
+  emptyAudioReceiveStream,
+  emptyAudioTransmitStream,
+  emptyVideoReceiveStream,
+  emptyVideoTransmitStream,
 } from '../mediaQualityMetrics/config';
 import LoggerProxy from '../common/logs/logger-proxy';
 
@@ -27,6 +31,10 @@ import {
   getAudioReceiverMqa,
   getVideoSenderMqa,
   getVideoReceiverMqa,
+  getAudioSenderStreamMqa,
+  getAudioReceiverStreamMqa,
+  getVideoSenderStreamMqa,
+  getVideoReceiverStreamMqa,
 } from './mqaUtil';
 import {ReceiveSlot} from '../multistream/receiveSlot';
 
@@ -153,6 +161,7 @@ export class StatsAnalyzer extends EventsScope {
   sendMqaData() {
     const newMqa = cloneDeep(emptyMqaInterval);
 
+    // Fill in empty stats items for lastMqaDataSent
     Object.keys(this.statsResults).forEach((mediaType) => {
       if (!this.lastMqaDataSent[mediaType]) {
         this.lastMqaDataSent[mediaType] = {};
@@ -165,53 +174,178 @@ export class StatsAnalyzer extends EventsScope {
       if (!this.lastMqaDataSent[mediaType].recv && mediaType.includes('-recv')) {
         this.lastMqaDataSent[mediaType].recv = {};
       }
+    });
+
+    // Create stats the first level, totals for senders and receivers
+    const audioSender = cloneDeep(emptyAudioTransmit);
+    const audioShareSender = cloneDeep(emptyAudioTransmit);
+    const audioReceiver = cloneDeep(emptyAudioReceive);
+    const audioShareReceiver = cloneDeep(emptyAudioReceive);
+    const videoSender = cloneDeep(emptyVideoTransmit);
+    const videoShareSender = cloneDeep(emptyVideoTransmit);
+    const videoReceiver = cloneDeep(emptyVideoReceive);
+    const videoShareReceiver = cloneDeep(emptyVideoReceive);
+
+    getAudioSenderMqa({
+      audioSender,
+      statsResults: this.statsResults,
+      lastMqaDataSent: this.lastMqaDataSent,
+      baseMediaType: 'audio-send',
+    });
+    newMqa.audioTransmit.push(audioSender);
+
+    getAudioSenderMqa({
+      audioSender: audioShareSender,
+      statsResults: this.statsResults,
+      lastMqaDataSent: this.lastMqaDataSent,
+      baseMediaType: 'audio-share-send',
+    });
+    newMqa.audioTransmit.push(audioShareSender);
+
+    getAudioReceiverMqa({
+      audioReceiver,
+      statsResults: this.statsResults,
+      lastMqaDataSent: this.lastMqaDataSent,
+      baseMediaType: 'audio-recv',
+    });
+    newMqa.audioReceive.push(audioReceiver);
+
+    getAudioReceiverMqa({
+      audioReceiver: audioShareReceiver,
+      statsResults: this.statsResults,
+      lastMqaDataSent: this.lastMqaDataSent,
+      baseMediaType: 'audio-share-recv',
+    });
+    newMqa.audioReceive.push(audioShareReceiver);
+
+    getVideoSenderMqa({
+      videoSender,
+      statsResults: this.statsResults,
+      lastMqaDataSent: this.lastMqaDataSent,
+      baseMediaType: 'video-send',
+    });
+    newMqa.videoTransmit.push(videoSender);
+
+    getVideoSenderMqa({
+      videoSender: videoShareSender,
+      statsResults: this.statsResults,
+      lastMqaDataSent: this.lastMqaDataSent,
+      baseMediaType: 'video-share-send',
+    });
+    newMqa.videoTransmit.push(videoShareSender);
+
+    getVideoReceiverMqa({
+      videoReceiver,
+      statsResults: this.statsResults,
+      lastMqaDataSent: this.lastMqaDataSent,
+      baseMediaType: 'video-recv',
+    });
+    newMqa.videoReceive.push(videoReceiver);
+
+    getVideoReceiverMqa({
+      videoReceiver: videoShareReceiver,
+      statsResults: this.statsResults,
+      lastMqaDataSent: this.lastMqaDataSent,
+      baseMediaType: 'video-share-recv',
+    });
+    newMqa.videoReceive.push(videoShareReceiver);
+
+    // Add stats for individual streams
+    Object.keys(this.statsResults).forEach((mediaType) => {
+      if (mediaType.includes('audio-send')) {
+        const audioSenderStream = cloneDeep(emptyAudioTransmitStream);
+
+        getAudioSenderStreamMqa({
+          audioSenderStream,
+          statsResults: this.statsResults,
+          lastMqaDataSent: this.lastMqaDataSent,
+          mediaType,
+        });
+        newMqa.audioTransmit[0].streams.push(audioSenderStream);
 
-      if (mediaType.includes('audio-send') || mediaType.includes('audio-share-send')) {
-        const audioSender = cloneDeep(emptyAudioTransmit);
+        this.lastMqaDataSent[mediaType].send = cloneDeep(this.statsResults[mediaType].send);
+      } else if (mediaType.includes('audio-share-send')) {
+        const audioSenderStream = cloneDeep(emptyAudioTransmitStream);
 
-        getAudioSenderMqa({
-          audioSender,
+        getAudioSenderStreamMqa({
+          audioSenderStream,
           statsResults: this.statsResults,
           lastMqaDataSent: this.lastMqaDataSent,
           mediaType,
         });
-        newMqa.audioTransmit.push(audioSender);
+        newMqa.audioTransmit[1].streams.push(audioSenderStream);
 
         this.lastMqaDataSent[mediaType].send = cloneDeep(this.statsResults[mediaType].send);
-      } else if (mediaType.includes('audio-recv') || mediaType.includes('audio-share-recv')) {
-        const audioReceiver = cloneDeep(emptyAudioReceive);
+      } else if (mediaType.includes('audio-recv')) {
+        const audioReceiverStream = cloneDeep(emptyAudioReceiveStream);
+
+        getAudioReceiverStreamMqa({
+          audioReceiverStream,
+          statsResults: this.statsResults,
+          lastMqaDataSent: this.lastMqaDataSent,
+          mediaType,
+        });
+        newMqa.audioReceive[0].streams.push(audioReceiverStream);
 
-        getAudioReceiverMqa({
-          audioReceiver,
+        this.lastMqaDataSent[mediaType].recv = cloneDeep(this.statsResults[mediaType].recv);
+      } else if (mediaType.includes('audio-share-recv')) {
+        const audioReceiverStream = cloneDeep(emptyAudioReceiveStream);
+
+        getAudioReceiverStreamMqa({
+          audioReceiverStream,
           statsResults: this.statsResults,
           lastMqaDataSent: this.lastMqaDataSent,
           mediaType,
         });
-        newMqa.audioReceive.push(audioReceiver);
+        newMqa.audioReceive[1].streams.push(audioReceiverStream);
 
         this.lastMqaDataSent[mediaType].recv = cloneDeep(this.statsResults[mediaType].recv);
-      } else if (mediaType.includes('video-send') || mediaType.includes('video-share-send')) {
-        const videoSender = cloneDeep(emptyVideoTransmit);
+      } else if (mediaType.includes('video-send')) {
+        const videoSenderStream = cloneDeep(emptyVideoTransmitStream);
+
+        getVideoSenderStreamMqa({
+          videoSenderStream,
+          statsResults: this.statsResults,
+          lastMqaDataSent: this.lastMqaDataSent,
+          mediaType,
+        });
+        newMqa.videoTransmit[0].streams.push(videoSenderStream);
+
+        this.lastMqaDataSent[mediaType].send = cloneDeep(this.statsResults[mediaType].send);
+      } else if (mediaType.includes('video-share-send')) {
+        const videoSenderStream = cloneDeep(emptyVideoTransmitStream);
 
-        getVideoSenderMqa({
-          videoSender,
+        getVideoSenderStreamMqa({
+          videoSenderStream,
           statsResults: this.statsResults,
           lastMqaDataSent: this.lastMqaDataSent,
           mediaType,
         });
-        newMqa.videoTransmit.push(videoSender);
+        newMqa.videoTransmit[1].streams.push(videoSenderStream);
 
         this.lastMqaDataSent[mediaType].send = cloneDeep(this.statsResults[mediaType].send);
-      } else if (mediaType.includes('video-recv') || mediaType.includes('video-share-recv')) {
-        const videoReceiver = cloneDeep(emptyVideoReceive);
+      } else if (mediaType.includes('video-recv')) {
+        const videoReceiverStream = cloneDeep(emptyVideoReceiveStream);
+
+        getVideoReceiverStreamMqa({
+          videoReceiverStream,
+          statsResults: this.statsResults,
+          lastMqaDataSent: this.lastMqaDataSent,
+          mediaType,
+        });
+        newMqa.videoReceive[0].streams.push(videoReceiverStream);
+
+        this.lastMqaDataSent[mediaType].recv = cloneDeep(this.statsResults[mediaType].recv);
+      } else if (mediaType.includes('video-share-recv')) {
+        const videoReceiverStream = cloneDeep(emptyVideoReceiveStream);
 
-        getVideoReceiverMqa({
-          videoReceiver,
+        getVideoReceiverStreamMqa({
+          videoReceiverStream,
           statsResults: this.statsResults,
           lastMqaDataSent: this.lastMqaDataSent,
           mediaType,
         });
-        newMqa.videoReceive.push(videoReceiver);
+        newMqa.videoReceive[1].streams.push(videoReceiverStream);
 
         this.lastMqaDataSent[mediaType].recv = cloneDeep(this.statsResults[mediaType].recv);
       }
@@ -381,7 +515,6 @@ export class StatsAnalyzer extends EventsScope {
         this.parseCandidate(getStatsResult, type, isSender, false);
         break;
       case 'media-source':
-        // @ts-ignore
         this.parseAudioSource(getStatsResult, type);
         break;
       default:
@@ -911,6 +1044,7 @@ export class StatsAnalyzer extends EventsScope {
     if (result.bytesReceived) {
       let kilobytes = 0;
       const receiveSlot = this.receiveSlotCallback(result.ssrc);
+      const sourceState = receiveSlot?.sourceState;
       const idAndCsi = receiveSlot
         ? `id: "${receiveSlot.id || ''}"${receiveSlot.csi ? ` and csi: ${receiveSlot.csi}` : ''}`
         : '';
@@ -938,10 +1072,10 @@ export class StatsAnalyzer extends EventsScope {
       this.statsResults[mediaType][sendrecvType].totalPacketsReceived = result.packetsReceived;
 
       if (currentPacketsReceived === 0) {
-        if (receiveSlot) {
+        if (receiveSlot && sourceState === 'live') {
           LoggerProxy.logger.info(
-            `StatsAnalyzer:index#processInboundRTPResult --> No packets received for receive slot ${idAndCsi}`,
-            currentPacketsReceived
+            `StatsAnalyzer:index#processInboundRTPResult --> No packets received for receive slot ${idAndCsi}. Total packets received on slot: `,
+            result.packetsReceived
           );
         }
       }