@webex/plugin-meetings 3.0.0-beta.20 → 3.0.0-beta.201

package/src/roap/request.ts

@@ -1,25 +1,25 @@
-/* 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 {REACHABILITY} from '../constants';
+import {LocusMediaRequest} from '../meeting/locusMediaRequest';
 
 /**
  * @class RoapRequest
  */
 export default class RoapRequest extends StatelessWebexPlugin {
   /**
-   * Joins a meeting via ROAP
+   * Returns reachability data.
    * @param {Object} localSdp
-   * @returns {Promise} returns a promise that resolves/rejects whatever the request does
+   * @returns {Object}
    */
-  async attachRechabilityData(localSdp) {
+  async attachReachabilityData(localSdp) {
+    let joinCookie;
+
     // @ts-ignore
     const reachabilityData = await this.webex.boundedStorage
-      .get(REACHABILITY.namespace, REACHABILITY.localStorage)
+      .get(REACHABILITY.namespace, REACHABILITY.localStorageResult)
       .catch(() => {});
 
     if (reachabilityData) {
@@ -37,7 +37,22 @@ export default class RoapRequest extends StatelessWebexPlugin {
       }
     }
 
-    return localSdp;
+    // @ts-ignore
+    const joinCookieRaw = await this.webex.boundedStorage
+      .get(REACHABILITY.namespace, REACHABILITY.localStorageJoinCookie)
+      .catch(() => {});
+
+    if (joinCookieRaw) {
+      try {
+        joinCookie = JSON.parse(joinCookieRaw);
+      } catch (e) {
+        LoggerProxy.logger.error(
+          `MeetingRequest#constructor --> Error in parsing join cookie data: ${e}`
+        );
+      }
+    }
+
+    return {localSdp, joinCookie};
   }
 
   /**
@@ -47,111 +62,102 @@ 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
    * @returns {Promise} returns the response/failure of the request
    */
-  sendRoap(options: {
+  async sendRoap(options: {
     roapMessage: any;
     locusSelfUrl: string;
     mediaId: string;
-    correlationId: string;
-    audioMuted: boolean;
-    videoMuted: boolean;
     meetingId: string;
-    preferTranscoding?: boolean;
+    locusMediaRequest?: LocusMediaRequest;
   }) {
-    const {roapMessage, locusSelfUrl, mediaId, correlationId, meetingId} = options;
+    const {roapMessage, locusSelfUrl, mediaId, meetingId, locusMediaRequest} = options;
 
     if (!mediaId) {
-      LoggerProxy.logger.info('Roap:request#sendRoap --> Race Condition /call mediaID not present');
+      LoggerProxy.logger.info('Roap:request#sendRoap --> sending empty mediaID');
     }
 
-    const mediaUrl = `${locusSelfUrl}/${MEDIA}`;
-    // @ts-ignore
-    const deviceUrl = this.webex.internal.device.url;
+    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,
+    });
 
     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
+    this.webex.internal.newMetrics.submitClientEvent({
+      name: 'client.locus.media.request',
+      options: {
+        meetingId,
+      },
+    });
 
-    return this.attachRechabilityData({
-      roapMessage,
-      // eslint-disable-next-line no-warning-comments
-      // TODO: check whats the need for video and audiomute
-      audioMuted: !!options.audioMuted,
-      videoMuted: !!options.videoMuted,
-    }).then((sdpWithReachability) => {
-      // @ts-ignore
-      return this.webex
-        .request({
-          uri: mediaUrl,
-          method: HTTP_VERBS.PUT,
-          body: {
-            device: {
-              url: deviceUrl,
-              // @ts-ignore
-              deviceType: this.config.meetings.deviceType,
-            },
-            correlationId,
-            localMedias: [
-              {
-                localSdp: JSON.stringify(sdpWithReachability),
-                mediaId: options.mediaId,
-              },
-            ],
-            clientMediaPreferences: {
-              preferTranscoding: options.preferTranscoding ?? true,
-            },
+    return locusMediaRequest
+      .send({
+        type: 'RoapMessage',
+        selfUrl: locusSelfUrl,
+        joinCookie,
+        mediaId,
+        roapMessage,
+        reachability: localSdpWithReachabilityData.reachability,
+      })
+      .then((res) => {
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.locus.media.response',
+          options: {
+            meetingId,
           },
-        })
-        .then((res) => {
-          Metrics.postEvent({event: eventType.MEDIA_RESPONSE, meetingId});
-
-          // always it will be the first mediaConnection Object
-          const mediaConnections =
-            res.body.mediaConnections &&
-            res.body.mediaConnections.length > 0 &&
-            res.body.mediaConnections[0];
-
-          LoggerProxy.logger.info(
-            `Roap:request#sendRoap --> response:${JSON.stringify(
-              mediaConnections,
-              null,
-              2
-            )}'\n StatusCode:'${res.statusCode}`
-          );
-          const {locus} = res.body;
-
-          locus.roapSeq = options.roapMessage.seq;
-
-          return {
-            locus,
-            ...(mediaConnections && {mediaConnections: res.body.mediaConnections}),
-          };
-        })
-        .catch((err) => {
-          Metrics.postEvent({
-            event: eventType.MEDIA_RESPONSE,
+        });
+        // always it will be the first mediaConnection Object
+        const mediaConnections =
+          res.body.mediaConnections &&
+          res.body.mediaConnections.length > 0 &&
+          res.body.mediaConnections[0];
+
+        LoggerProxy.logger.debug(
+          `Roap:request#sendRoap --> response:${JSON.stringify(
+            mediaConnections,
+            null,
+            2
+          )}'\n StatusCode:'${res.statusCode}`
+        );
+        const {locus} = res.body;
+
+        locus.roapSeq = options.roapMessage.seq;
+
+        return {
+          locus,
+          ...(mediaConnections && {mediaConnections: res.body.mediaConnections}),
+        };
+      })
+      .catch((err) => {
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.locus.media.response',
+          options: {
             meetingId,
-            data: {error: Metrics.parseLocusError(err, true)},
-          });
-          LoggerProxy.logger.error(
-            `Roap:request#sendRoap --> Error:${JSON.stringify(err, null, 2)}`
-          );
-          LoggerProxy.logger.error(
-            `Roap:request#sendRoapRequest --> errorBody:${JSON.stringify(
-              roapMessage,
-              null,
-              2
-            )} + '\\n mediaId:'${options.mediaId}`
-          );
-          throw err;
+            rawError: err,
+          },
         });
-    });
+        LoggerProxy.logger.error(`Roap:request#sendRoap --> Error:${JSON.stringify(err, null, 2)}`);
+        LoggerProxy.logger.error(
+          `Roap:request#sendRoapRequest --> errorBody:${JSON.stringify(
+            roapMessage,
+            null,
+            2
+          )} + '\\n mediaId:'${options.mediaId}`
+        );
+        throw err;
+      });
   }
 }

package/src/roap/turnDiscovery.ts

@@ -176,15 +176,12 @@ 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.isAudioMuted(),
-        videoMuted: meeting.isVideoMuted(),
         meetingId: meeting.id,
-        preferTranscoding: !meeting.isMultistream,
+        locusMediaRequest: meeting.locusMediaRequest,
       })
       .then(({mediaConnections}) => {
         if (mediaConnections) {
@@ -213,14 +210,53 @@ export default class TurnDiscovery {
       locusSelfUrl: meeting.selfUrl,
       // @ts-ignore - fix type
       mediaId: meeting.mediaId,
-      correlationId: meeting.correlationId,
-      audioMuted: meeting.isAudioMuted(),
-      videoMuted: meeting.isVideoMuted(),
       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> {
+    // @ts-ignore - fix type
+    const isAnyClusterReachable = await meeting.webex.meetings.reachability.isAnyClusterReachable();
+
+    if (isAnyClusterReachable) {
+      LoggerProxy.logger.info(
+        'Roap:turnDiscovery#getSkipReason --> reachability has not failed, skipping TURN discovery'
+      );
+
+      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 '';
+  }
+
+  /**
+   * 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:
@@ -239,29 +275,15 @@ export default class TurnDiscovery {
    * @returns {Promise}
    */
   async doTurnDiscovery(meeting: Meeting, isReconnecting?: boolean) {
-    // @ts-ignore - fix type
-    const isAnyClusterReachable = await meeting.webex.meetings.reachability.isAnyClusterReachable();
-
-    if (isAnyClusterReachable) {
-      LoggerProxy.logger.info(
-        'Roap:turnDiscovery#doTurnDiscovery --> reachability has not failed, skipping TURN discovery'
-      );
+    const 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'
-      );
-
-      return {turnServerInfo: undefined, turnDiscoverySkippedReason: 'config'};
-    }
-
     return this.sendRoapTurnDiscoveryRequest(meeting, isReconnecting)
       .then(() => this.waitForTurnDiscoveryResponse())
       .then(() => this.sendRoapOK(meeting))

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,96 @@
+import uuid from 'uuid';
+import RTC_METRICS from './constants';
+
+/**
+ * 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;
+
+  /**
+   * Initialize the interval.
+   *
+   * @param {object} webex - The main `webex` object.
+   * @param {string} meetingId - The meeting id.
+   */
+  constructor(webex, meetingId) {
+    // `window` is used to prevent typescript from returning a NodeJS.Timer.
+    this.intervalId = window.setInterval(this.checkMetrics.bind(this), 30 * 1000);
+    this.meetingId = meetingId;
+    this.webex = webex;
+    this.correlationId = uuid.v4();
+    // 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);
+  }
+
+  /**
+   * Check to see if the metrics queue has any items.
+   *
+   * @returns {void}
+   */
+  private checkMetrics() {
+    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) {
+      this.metricsQueue.push(data);
+    }
+  }
+
+  /**
+   * Clear the metrics interval.
+   *
+   * @returns {void}
+   */
+  closeMetrics() {
+    this.checkMetrics();
+    clearInterval(this.intervalId);
+  }
+
+  /**
+   * 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: {
+        type: 'webrtc',
+        version: '1.0.0',
+        userId: this.webex.internal.device.userId,
+        meetingId: this.meetingId,
+        correlationId: this.correlationId,
+        metrics: this.metricsQueue,
+      },
+    });
+  }
+}

package/src/statsAnalyzer/global.ts

@@ -1,55 +1,5 @@
 const STATS_DEFAULT = {
   encryption: 'sha-256',
-  audio: {
-    send: {
-      trackLabel: '',
-      maxPacketLossRatio: 0,
-      availableBandwidth: 0,
-      bytesSent: 0,
-      meanRemoteJitter: [],
-      meanRoundTripTime: [],
-    },
-    recv: {
-      availableBandwidth: 0,
-      bytesReceived: 0,
-      meanRtpJitter: [],
-      meanRoundTripTime: [],
-    },
-  },
-  video: {
-    send: {
-      trackLabel: '',
-      maxPacketLossRatio: 0,
-      availableBandwidth: 0,
-      meanRemoteJitter: [],
-      meanRoundTripTime: [],
-    },
-    recv: {
-      availableBandwidth: 0,
-      totalPacketsLost: 0,
-      meanRtpJitter: [],
-      meanRoundTripTime: [],
-    },
-    latency: 0,
-    packetsLost: 0,
-  },
-  share: {
-    send: {
-      maxPacketLossRatio: 0,
-      availableBandwidth: 0,
-      totalPacketsLost: 0,
-      meanRemoteJitter: [],
-      meanRoundTripTime: [],
-    },
-    recv: {
-      availableBandwidth: 0,
-      meanRtpJitter: [],
-      meanRoundTripTime: [],
-    },
-
-    latency: 0,
-    packetsLost: 0,
-  },
   bandwidth: {
     systemBandwidth: 0,
     sentPerSecond: 0,
@@ -77,51 +27,8 @@ const STATS_DEFAULT = {
       networkType: [],
     },
   },
-  resolutions: {
-    audio: {
-      send: {
-        width: 0,
-        height: 0,
-      },
-      recv: {
-        width: 0,
-        height: 0,
-      },
-    },
-    video: {
-      send: {
-        width: 0,
-        height: 0,
-      },
-      recv: {
-        width: 0,
-        height: 0,
-      },
-    },
-    share: {
-      send: {
-        width: 0,
-        height: 0,
-      },
-      recv: {
-        width: 0,
-        height: 0,
-      },
-    },
-  },
+  resolutions: {},
   internal: {
-    audio: {
-      send: {},
-      recv: {},
-    },
-    video: {
-      send: {},
-      recv: {},
-    },
-    share: {
-      send: {},
-      recv: {},
-    },
     remote: {},
     candidates: {},
   },