@webex/plugin-meetings 3.0.0-beta.261 → 3.0.0-beta.263

package/src/meeting/index.ts

@@ -5817,12 +5817,16 @@ export default class Meeting extends StatelessWebexPlugin {
         return Promise.resolve();
       })
       .then(() => this.mediaProperties.getCurrentConnectionType())
-      .then((connectionType) => {
+      .then(async (connectionType) => {
+        // @ts-ignore
+        const reachabilityStats = await this.webex.meetings.reachability.getReachabilityMetrics();
+
         Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADD_MEDIA_SUCCESS, {
           correlation_id: this.correlationId,
           locus_id: this.locusUrl.split('/').pop(),
           connectionType,
           isMultistream: this.isMultistream,
+          ...reachabilityStats,
         });
         // @ts-ignore
         this.webex.internal.newMetrics.submitClientEvent({
@@ -5838,9 +5842,12 @@ export default class Meeting extends StatelessWebexPlugin {
         // We can log ReceiveSlot SSRCs only after the SDP exchange, so doing it here:
         this.remoteMediaManager?.logAllReceiveSlots();
       })
-      .catch((error) => {
+      .catch(async (error) => {
         LoggerProxy.logger.error(`${LOG_HEADER} failed to establish media connection: `, error);
 
+        // @ts-ignore
+        const reachabilityMetrics = await this.webex.meetings.reachability.getReachabilityMetrics();
+
         Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE, {
           correlation_id: this.correlationId,
           locus_id: this.locusUrl.split('/').pop(),
@@ -5865,38 +5872,37 @@ export default class Meeting extends StatelessWebexPlugin {
               ?.iceConnectionState ||
             this.mediaProperties.webrtcMediaConnection?.mediaConnection?.pc?.iceConnectionState ||
             'unknown',
+          ...reachabilityMetrics,
         });
 
         // Clean up stats analyzer, peer connection, and turn off listeners
-        const stopStatsAnalyzer = this.statsAnalyzer
-          ? this.statsAnalyzer.stopAnalyzer()
-          : Promise.resolve();
+        if (this.statsAnalyzer) {
+          await this.statsAnalyzer.stopAnalyzer();
+        }
 
-        return stopStatsAnalyzer.then(() => {
-          this.statsAnalyzer = null;
+        this.statsAnalyzer = null;
 
-          if (this.mediaProperties.webrtcMediaConnection) {
-            this.closePeerConnections();
-            this.unsetPeerConnections();
-          }
+        if (this.mediaProperties.webrtcMediaConnection) {
+          this.closePeerConnections();
+          this.unsetPeerConnections();
+        }
 
-          // Upload logs on error while adding media
-          Trigger.trigger(
-            this,
-            {
-              file: 'meeting/index',
-              function: 'addMedia',
-            },
-            EVENTS.REQUEST_UPLOAD_LOGS,
-            this
-          );
+        // Upload logs on error while adding media
+        Trigger.trigger(
+          this,
+          {
+            file: 'meeting/index',
+            function: 'addMedia',
+          },
+          EVENTS.REQUEST_UPLOAD_LOGS,
+          this
+        );
 
-          if (error instanceof Errors.SdpError) {
-            this.leave({reason: MEETING_REMOVED_REASON.MEETING_CONNECTION_FAILED});
-          }
+        if (error instanceof Errors.SdpError) {
+          this.leave({reason: MEETING_REMOVED_REASON.MEETING_CONNECTION_FAILED});
+        }
 
-          throw error;
-        });
+        throw error;
       });
   }
 

package/src/meetings/index.ts

@@ -61,6 +61,7 @@ import MeetingsUtil from './util';
 import PermissionError from '../common/errors/permission';
 import {INoiseReductionEffect, IVirtualBackgroundEffect} from './meetings.types';
 import {SpaceIDDeprecatedError} from '../common/errors/webex-errors';
+import NoMeetingInfoError from '../common/errors/no-meeting-info';
 
 let mediaLogger;
 
@@ -1043,6 +1044,7 @@ export default class Meetings extends WebexPlugin {
    * @param {Boolean} useRandomDelayForInfo - whether a random delay should be added to fetching meeting info
    * @param {Object} infoExtraParams extra parameters to be provided when fetching meeting info
    * @param {string} correlationId - the optional specified correlationId
+   * @param {Boolean} failOnMissingMeetingInfo - whether to throw an error if meeting info fails to fetch (for calls that are not 1:1 or content share)
    * @returns {Promise<Meeting>} A new Meeting.
    * @public
    * @memberof Meetings
@@ -1052,7 +1054,8 @@ export default class Meetings extends WebexPlugin {
     type: string = null,
     useRandomDelayForInfo = false,
     infoExtraParams = {},
-    correlationId: string = undefined
+    correlationId: string = undefined,
+    failOnMissingMeetingInfo = false
   ) {
     // TODO: type should be from a dictionary
 
@@ -1106,7 +1109,8 @@ export default class Meetings extends WebexPlugin {
               type,
               useRandomDelayForInfo,
               infoExtraParams,
-              correlationId
+              correlationId,
+              failOnMissingMeetingInfo
             ).then((createdMeeting: any) => {
               // If the meeting was successfully created.
               if (createdMeeting && createdMeeting.on) {
@@ -1161,6 +1165,7 @@ export default class Meetings extends WebexPlugin {
    * @param {Boolean} useRandomDelayForInfo whether a random delay should be added to fetching meeting info
    * @param {Object} infoExtraParams extra parameters to be provided when fetching meeting info
    * @param {String} correlationId the optional specified correlationId
+   * @param {Boolean} failOnMissingMeetingInfo - whether to throw an error if meeting info fails to fetch (for calls that are not 1:1 or content share)
    * @returns {Promise} a new meeting instance complete with meeting info and destination
    * @private
    * @memberof Meetings
@@ -1170,7 +1175,8 @@ export default class Meetings extends WebexPlugin {
     type: string = null,
     useRandomDelayForInfo = false,
     infoExtraParams = {},
-    correlationId: string = undefined
+    correlationId: string = undefined,
+    failOnMissingMeetingInfo = false
   ) {
     const meeting = new Meeting(
       {
@@ -1239,10 +1245,18 @@ export default class Meetings extends WebexPlugin {
         !(err instanceof PasswordError) &&
         !(err instanceof PermissionError)
       ) {
-        // if there is no meeting info we assume its a 1:1 call or wireless share
         LoggerProxy.logger.info(
           `Meetings:index#createMeeting --> Info Unable to fetch meeting info for ${destination}.`
         );
+        if (failOnMissingMeetingInfo) {
+          LoggerProxy.logger.info(
+            `Meetings:index#createMeeting --> Destroying meeting due to missing meeting info.`
+          );
+          // @ts-ignore
+          this.destroy(meeting, MEETING_REMOVED_REASON.MISSING_MEETING_INFO);
+          throw new NoMeetingInfoError();
+        }
+        // if there is no meeting info and no error should be thrown then we assume its a 1:1 call or wireless share
         LoggerProxy.logger.info(
           'Meetings:index#createMeeting --> Info assuming this destination is a 1:1 or wireless share'
         );

package/src/reachability/index.ts

@@ -16,9 +16,20 @@ import ReachabilityRequest from './request';
 const DEFAULT_TIMEOUT = 3000;
 const VIDEO_MESH_TIMEOUT = 1000;
 
+export type ReachabilityMetrics = {
+  reachability_public_udp_success: number;
+  reachability_public_udp_failed: number;
+  reachability_public_tcp_success: number;
+  reachability_public_tcp_failed: number;
+  reachability_vmn_udp_success: number;
+  reachability_vmn_udp_failed: number;
+  reachability_vmn_tcp_success: number;
+  reachability_vmn_tcp_failed: number;
+};
+
 // result for a specific transport protocol (like udp or tcp)
 export type TransportResult = {
-  reachable: 'true' | 'false';
+  reachable?: 'true' | 'false';
   latencyInMilliseconds?: string;
   clientMediaIPs?: string[];
   untested?: 'true';
@@ -138,6 +149,58 @@ export default class Reachability {
     }
   }
 
+  /**
+   * Returns statistics about last reachability results. The returned value is an object
+   * with a flat list of properties so that it can be easily sent with metrics
+   *
+   * @returns {Promise} Promise with metrics values, it never rejects/throws.
+   */
+  async getReachabilityMetrics(): Promise<ReachabilityMetrics> {
+    const stats: ReachabilityMetrics = {
+      reachability_public_udp_success: 0,
+      reachability_public_udp_failed: 0,
+      reachability_public_tcp_success: 0,
+      reachability_public_tcp_failed: 0,
+      reachability_vmn_udp_success: 0,
+      reachability_vmn_udp_failed: 0,
+      reachability_vmn_tcp_success: 0,
+      reachability_vmn_tcp_failed: 0,
+    };
+
+    const updateStats = (clusterType: 'public' | 'vmn', result: ReachabilityResult) => {
+      if (result.udp?.reachable) {
+        const outcome = result.udp.reachable === 'true' ? 'success' : 'failed';
+        stats[`reachability_${clusterType}_udp_${outcome}`] += 1;
+      }
+      if (result.tcp?.reachable) {
+        const outcome = result.tcp.reachable === 'true' ? 'success' : 'failed';
+        stats[`reachability_${clusterType}_tcp_${outcome}`] += 1;
+      }
+    };
+
+    try {
+      // @ts-ignore
+      const resultsJson = await this.webex.boundedStorage.get(
+        REACHABILITY.namespace,
+        REACHABILITY.localStorageResult
+      );
+
+      const internalResults: InternalReachabilityResults = JSON.parse(resultsJson);
+
+      Object.values(internalResults).forEach((result) => {
+        updateStats(result.isVideoMesh ? 'vmn' : 'public', result);
+      });
+    } catch (e) {
+      // empty storage, that's ok
+      LoggerProxy.logger.warn(
+        'Roap:request#getReachabilityMetrics --> Error parsing reachability data: ',
+        e
+      );
+    }
+
+    return stats;
+  }
+
   /**
    * Reachability results as an object in the format that backend expects
    *

package/test/unit/spec/meeting/index.js

@@ -44,14 +44,12 @@ import {
   StreamEventNames,
 } from '@webex/media-helpers';
 import * as StatsAnalyzerModule from '@webex/plugin-meetings/src/statsAnalyzer';
-import * as MuteStateModule from '@webex/plugin-meetings/src/meeting/muteState';
 import EventsScope from '@webex/plugin-meetings/src/common/events/events-scope';
 import Meetings, {CONSTANTS} from '@webex/plugin-meetings';
 import Meeting from '@webex/plugin-meetings/src/meeting';
 import Members from '@webex/plugin-meetings/src/members';
 import * as MembersImport from '@webex/plugin-meetings/src/members';
 import Roap from '@webex/plugin-meetings/src/roap';
-import RoapRequest from '@webex/plugin-meetings/src/roap/request';
 import MeetingRequest from '@webex/plugin-meetings/src/meeting/request';
 import * as MeetingRequestImport from '@webex/plugin-meetings/src/meeting/request';
 import LocusInfo from '@webex/plugin-meetings/src/locus-info';
@@ -81,7 +79,6 @@ import {
   UserNotJoinedError,
   MeetingNotActiveError,
   UserInLobbyError,
-  NoMediaEstablishedYetError,
 } from '../../../../src/common/errors/webex-errors';
 import WebExMeetingsErrors from '../../../../src/common/errors/webex-meetings-error';
 import ParameterError from '../../../../src/common/errors/parameter';
@@ -89,19 +86,14 @@ import PasswordError from '../../../../src/common/errors/password-error';
 import CaptchaError from '../../../../src/common/errors/captcha-error';
 import PermissionError from '../../../../src/common/errors/permission';
 import IntentToJoinError from '../../../../src/common/errors/intent-to-join';
-import DefaultSDKConfig from '../../../../src/config';
 import testUtils from '../../../utils/testUtils';
 import {
   MeetingInfoV2CaptchaError,
   MeetingInfoV2PasswordError,
   MeetingInfoV2PolicyError,
 } from '../../../../src/meeting-info/meeting-info-v2';
-import {ANNOTATION_POLICY} from '../../../../src/annotation/constants';
 
 
-// Non-stubbed function
-const {getDisplayMedia} = Media;
-
 describe('plugin-meetings', () => {
   const logger = {
     info: () => {},
@@ -228,6 +220,11 @@ describe('plugin-meetings', () => {
     webex.credentials.getOrgId = sinon.stub().returns('fake-org-id');
     webex.internal.metrics.submitClientMetrics = sinon.stub().returns(Promise.resolve());
     webex.meetings.uploadLogs = sinon.stub().returns(Promise.resolve());
+    webex.meetings.reachability = {
+      isAnyPublicClusterReachable: sinon.stub().resolves(true),
+      getReachabilityResults: sinon.stub().resolves(undefined),
+      getReachabilityMetrics: sinon.stub().resolves({}),
+    };
     webex.internal.llm.on = sinon.stub();
     membersSpy = sinon.spy(MembersImport, 'default');
     meetingRequestSpy = sinon.spy(MeetingRequestImport, 'default');
@@ -1170,8 +1167,15 @@ describe('plugin-meetings', () => {
           }
         });
 
-        it('should reset the statsAnalyzer to null if addMedia throws an error', async () => {
+        it('should send metrics and reset the statsAnalyzer to null if addMedia throws an error', async () => {
           meeting.meetingState = 'ACTIVE';
+          meeting.webex.meetings.reachability = {
+            getReachabilityMetrics: sinon.stub().resolves({
+              someReachabilityMetric1: 'some value1',
+              someReachabilityMetric2: 'some value2'
+            }),
+          };
+
           // setup the mock to return an incomplete object - this will cause addMedia to fail
           // because some methods (like on() or initiateOffer()) are missing
           Media.createMediaConnection = sinon.stub().returns({
@@ -1195,6 +1199,8 @@ describe('plugin-meetings', () => {
             signalingState: 'unknown',
             connectionState: 'unknown',
             iceConnectionState: 'unknown',
+            someReachabilityMetric1: 'some value1',
+            someReachabilityMetric2: 'some value2',
           });
         });
 
@@ -1546,6 +1552,12 @@ describe('plugin-meetings', () => {
 
         it('should send ADD_MEDIA_SUCCESS metrics', async () => {
           meeting.meetingState = 'ACTIVE';
+          meeting.webex.meetings.reachability = {
+            getReachabilityMetrics: sinon.stub().resolves({
+              someReachabilityMetric1: 'some value1',
+              someReachabilityMetric2: 'some value2'
+            }),
+          };
           await meeting.addMedia({
             mediaSettings: {},
           });
@@ -1556,6 +1568,8 @@ describe('plugin-meetings', () => {
             locus_id: meeting.locusUrl.split('/').pop(),
             connectionType: 'udp',
             isMultistream: false,
+            someReachabilityMetric1: 'some value1',
+            someReachabilityMetric2: 'some value2'
           });
 
           assert.called(webex.internal.newMetrics.submitClientEvent);
@@ -1792,10 +1806,6 @@ describe('plugin-meetings', () => {
           meeting.setMercuryListener = sinon.stub();
           meeting.locusInfo.onFullLocus = sinon.stub();
           meeting.webex.meetings.geoHintInfo = {regionCode: 'EU', countryCode: 'UK'};
-          meeting.webex.meetings.reachability = {
-            isAnyPublicClusterReachable: sinon.stub().resolves(true),
-            getReachabilityResults: sinon.stub().resolves(undefined),
-          };
           meeting.roap.doTurnDiscovery = sinon
             .stub()
             .resolves({turnServerInfo: {}, turnDiscoverySkippedReason: 'reachability'});

package/test/unit/spec/meetings/index.js

@@ -36,6 +36,7 @@ import { forEach } from 'lodash';
 import PasswordError from '@webex/plugin-meetings/src/common/errors/password-error';
 import PermissionError from '@webex/plugin-meetings/src/common/errors/permission';
 import {NoiseReductionEffect,VirtualBackgroundEffect} from '@webex/media-helpers';
+import NoMeetingInfoError from '../../../../src/common/errors/no-meeting-info';
 
 describe('plugin-meetings', () => {
   const logger = {
@@ -662,15 +663,28 @@ describe('plugin-meetings', () => {
           });
         });
 
-        it('calls createMeeting and returns its promise', async () => {
-          const FAKE_USE_RANDOM_DELAY = true;
-          const correlationId = 'my-correlationId';
-          const create = webex.meetings.create(test1, test2, FAKE_USE_RANDOM_DELAY, {}, correlationId);
+        const FAKE_USE_RANDOM_DELAY = true;
+        const correlationId = 'my-correlationId';
+
+        const checkCallCreateMeeting = async (createParameters, createMeetingParameters) => {
+          const create = webex.meetings.create(...createParameters);
 
           assert.exists(create.then);
           await create;
           assert.calledOnce(webex.meetings.createMeeting);
-          assert.calledWith(webex.meetings.createMeeting, test1, test2, FAKE_USE_RANDOM_DELAY, {}, correlationId);
+          assert.calledWith(webex.meetings.createMeeting, ...createMeetingParameters);
+        } 
+
+        it('calls createMeeting and returns its promise', async () => {
+          checkCallCreateMeeting([test1, test2, FAKE_USE_RANDOM_DELAY, {}, correlationId, true], [test1, test2, FAKE_USE_RANDOM_DELAY, {}, correlationId, true]);
+        });
+
+        it('calls createMeeting when failOnMissingMeetinginfo is undefined and returns its promise', async () => {
+          checkCallCreateMeeting([test1, test2, FAKE_USE_RANDOM_DELAY, {}, correlationId, undefined], [test1, test2, FAKE_USE_RANDOM_DELAY, {}, correlationId, false]);
+        });
+
+        it('calls createMeeting when failOnMissingMeetinginfo is false and returns its promise', async () => {
+          checkCallCreateMeeting([test1, test2, FAKE_USE_RANDOM_DELAY, {}, correlationId, false], [test1, test2, FAKE_USE_RANDOM_DELAY, {}, correlationId, false]);
         });
 
         it('calls createMeeting with extra info params and returns its promise', async () => {
@@ -1346,37 +1360,63 @@ describe('plugin-meetings', () => {
             webex.meetings.meetingInfo.fetchMeetingInfo = sinon
               .stub()
               .returns(Promise.reject(new Error('test')));
+            webex.meetings.destroy = sinon
+              .stub()
+              .returns(Promise.resolve());
+            webex.meetings.createMeeting = sinon.spy(webex.meetings.createMeeting);
           });
-          it('creates the meeting from a rejected meeting info fetch', async () => {
-            const meeting = await webex.meetings.createMeeting('test destination', 'test type');
 
-            assert.instanceOf(
-              meeting,
-              Meeting,
-              'createMeeting should eventually resolve to a Meeting Object'
-            );
-            assert.calledOnce(webex.meetings.meetingInfo.fetchMeetingInfo);
-            assert.calledOnce(MeetingsUtil.getMeetingAddedType);
-            assert.calledThrice(TriggerProxy.trigger);
-            assert.calledWith(
-              webex.meetings.meetingInfo.fetchMeetingInfo,
-              'test destination',
-              'test type'
-            );
-            assert.calledWith(MeetingsUtil.getMeetingAddedType, 'test type');
-            assert.calledWith(
-              TriggerProxy.trigger,
-              sinon.match.instanceOf(Meetings),
-              {
-                file: 'meetings',
-                function: 'createMeeting',
-              },
-              'meeting:added',
-              {
-                meeting: sinon.match.instanceOf(Meeting),
-                type: 'test meeting added type',
+          const checkCreateMeetingWithNoMeetingInfo = async (failOnMissingMeetingInfo, destroy) => {
+            try {
+              const meeting = await webex.meetings.createMeeting('test destination', 'test type', undefined, undefined, undefined, failOnMissingMeetingInfo);
+              
+              assert.instanceOf(
+                meeting,
+                Meeting,
+                'createMeeting should eventually resolve to a Meeting Object'
+              );
+              assert.calledOnce(webex.meetings.meetingInfo.fetchMeetingInfo);
+              assert.calledOnce(MeetingsUtil.getMeetingAddedType);
+              assert.calledThrice(TriggerProxy.trigger);
+              assert.calledWith(
+                webex.meetings.meetingInfo.fetchMeetingInfo,
+                'test destination',
+                'test type'
+              );
+  
+              if (destroy) {
+                assert.calledWith(webex.meetings.destroy, sinon.match.instanceOf(Meeting), 'MISSING_MEETING_INFO')
+                assert.notCalled(MeetingsUtil.getMeetingAddedType);
+                assert.notCalled(TriggerProxy.trigger);
+                assert.throw(webex.meetings.createMeeting, 'meeting information not found');
+              } else {
+                assert.notCalled(webex.meetings.destroy);
+                assert.calledWith(MeetingsUtil.getMeetingAddedType, 'test type');
+                assert.calledWith(
+                  TriggerProxy.trigger,
+                  sinon.match.instanceOf(Meetings),
+                  {
+                    file: 'meetings',
+                    function: 'createMeeting',
+                  },
+                  'meeting:added',
+                  {
+                    meeting: sinon.match.instanceOf(Meeting),
+                    type: 'test meeting added type',
+                  }
+                );
               }
-            );
+            } catch (err) { 
+              assert.instanceOf(err, NoMeetingInfoError);
+            }
+          }
+
+          it('creates the meeting from a rejected meeting info fetch', async () => {
+            checkCreateMeetingWithNoMeetingInfo(false, false);
+          });
+
+          it('creates the meeting from a rejected meeting info fetch and destroys it if failOnMissingMeetingInfo', async () => {
+            checkCreateMeetingWithNoMeetingInfo(true, true);
           });
         });