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

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/reachability/index.ts

@@ -328,8 +328,6 @@ describe('getReachabilityResults', () => {
 
   beforeEach(() => {
     webex = new MockWebex();
-
-    // sinon.stub(MeetingUtil, 'getIpVersion').returns(IP_VERSION.unknown);
   });
 
   afterEach(() => {
@@ -416,3 +414,211 @@ describe('getReachabilityResults', () => {
     );
   });
 });
+
+describe('getReachabilityMetrics', () => {
+  let webex;
+
+  beforeEach(() => {
+    webex = new MockWebex();
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  const runCheck = async (mockStorage: any, expectedResult: any) => {
+    if (mockStorage) {
+      await webex.boundedStorage.put(
+        'Reachability',
+        'reachability.result',
+        JSON.stringify(mockStorage)
+      );
+    }
+    const reachability = new Reachability(webex);
+    const result = await reachability.getReachabilityMetrics();
+
+    assert.deepEqual(result, expectedResult);
+  };
+
+  it('returns all zeros if reading from local storage fails', async () => {
+    sinon.stub(webex.boundedStorage, 'get').rejects(new Error('fake error'));
+
+    const reachability = new Reachability(webex);
+
+    const result = await reachability.getReachabilityMetrics();
+
+    assert.deepEqual(result, {
+      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,
+    });
+  });
+
+  it('returns correct stats based on local storage results', async () => {
+    await runCheck(
+      // mock storage:
+      {
+        public1: {
+          udp: {reachable: 'true', latencyInMilliseconds: '100'},
+          tcp: {untested: 'true'},
+          xtls: {untested: 'true'},
+        },
+        vmn1: {
+          udp: {reachable: 'true', latencyInMilliseconds: '200'},
+          tcp: {reachable: 'false'},
+          xtls: {untested: 'true'},
+          isVideoMesh: true,
+        },
+        vmn2: {
+          udp: {untested: 'true'},
+          tcp: {reachable: 'true', latencyInMilliseconds: '100', clientMediaIPs: ['10.10.10.10']},
+          xtls: {untested: 'true'},
+          isVideoMesh: true,
+          someOtherField: 'any value',
+        },
+        public2: {
+          udp: {reachable: 'false', latencyInMilliseconds: '300'},
+          tcp: {reachable: 'false', untested: 'true'},
+          xtls: {untested: 'true'},
+          someOtherField: 'any value',
+        },
+        public3: {
+          udp: {reachable: 'true', latencyInMilliseconds: '400', clientMediaIPs: ['10.10.10.10']},
+          tcp: {reachable: 'true', latencyInMilliseconds: '100', clientMediaIPs: ['10.10.10.10']},
+          xtls: {untested: 'true'},
+          isVideoMesh: false,
+          someOtherField: 'any value',
+        },
+        public4: {
+          udp: {reachable: 'true', latencyInMilliseconds: '40', clientMediaIPs: ['10.10.10.11']},
+          tcp: {reachable: 'true', latencyInMilliseconds: '100', clientMediaIPs: ['10.10.10.11']},
+          xtls: {untested: 'true'},
+          isVideoMesh: false,
+          someOtherField: 'any value',
+        },
+        public5: {
+          udp: {reachable: 'false'},
+          tcp: {untested: 'true'},
+          xtls: {untested: 'true'},
+          isVideoMesh: false,
+          someOtherField: 'any value',
+        },
+      },
+      // expected result:
+      {
+        reachability_public_udp_success: 3,
+        reachability_public_udp_failed: 2,
+        reachability_public_tcp_success: 2,
+        reachability_public_tcp_failed: 1,
+        reachability_vmn_udp_success: 1,
+        reachability_vmn_udp_failed: 0,
+        reachability_vmn_tcp_success: 1,
+        reachability_vmn_tcp_failed: 1,
+      }
+    );
+  });
+
+  it('returns correct stats when only public nodes were tested', async () => {
+    await runCheck(
+      // mock storage:
+      {
+        public1: {
+          udp: {reachable: 'true', latencyInMilliseconds: '400', clientMediaIPs: ['10.10.10.10']},
+          tcp: {reachable: 'true', latencyInMilliseconds: '100', clientMediaIPs: ['10.10.10.10']},
+          xtls: {untested: 'true'},
+          isVideoMesh: false,
+        },
+        public2: {
+          udp: {reachable: 'true', latencyInMilliseconds: '100'},
+          tcp: {untested: 'true'},
+          xtls: {untested: 'true'},
+        },
+        public3: {
+          udp: {reachable: 'false', latencyInMilliseconds: '300'},
+          tcp: {reachable: 'false', untested: 'true'},
+          xtls: {untested: 'true'},
+          someOtherField: 'any value',
+        },
+        public4: {
+          udp: {untested: 'true'},
+          tcp: {reachable: 'false'},
+          xtls: {untested: 'true'},
+          isVideoMesh: false,
+          someOtherField: 'any value',
+        },
+        public5: {
+          udp: {reachable: 'true', latencyInMilliseconds: '400', clientMediaIPs: ['10.10.10.10']},
+          tcp: {untested: 'true'},
+          xtls: {untested: 'true'},
+        },
+      },
+      // expected result:
+      {
+        reachability_public_udp_success: 3,
+        reachability_public_udp_failed: 1,
+        reachability_public_tcp_success: 1,
+        reachability_public_tcp_failed: 2,
+        reachability_vmn_udp_success: 0,
+        reachability_vmn_udp_failed: 0,
+        reachability_vmn_tcp_success: 0,
+        reachability_vmn_tcp_failed: 0,
+      }
+    );
+  });
+
+  it('returns correct stats when only video mesh nodes were tested', async () => {
+    await runCheck(
+      // mock storage:
+      {
+        vmn1: {
+          udp: {reachable: 'false'},
+          tcp: {reachable: 'true', latencyInMilliseconds: '100', clientMediaIPs: ['10.10.10.10']},
+          xtls: {untested: 'true'},
+          isVideoMesh: true,
+        },
+        vmn2: {
+          udp: {reachable: 'true', latencyInMilliseconds: '200', clientMediaIPs: ['10.10.10.10']},
+          tcp: {untested: 'true'},
+          xtls: {untested: 'true'},
+          isVideoMesh: true,
+        },
+        vmn3: {
+          udp: {reachable: 'true', latencyInMilliseconds: '300', clientMediaIPs: ['10.10.10.10']},
+          tcp: {reachable: 'false', untested: 'true'},
+          xtls: {untested: 'true'},
+          isVideoMesh: true,
+        },
+        vmn4: {
+          udp: {untested: 'true'},
+          tcp: {reachable: 'false'},
+          xtls: {untested: 'true'},
+          isVideoMesh: true,
+          someOtherField: 'any value',
+        },
+        vmn5: {
+          udp: {reachable: 'true', latencyInMilliseconds: '200', clientMediaIPs: ['10.10.10.10']},
+          tcp: {reachable: 'false'},
+          xtls: {untested: 'true'},
+          isVideoMesh: true,
+          someOtherField: 'any value',
+        },
+      },
+      // expected result:
+      {
+        reachability_public_udp_success: 0,
+        reachability_public_udp_failed: 0,
+        reachability_public_tcp_success: 0,
+        reachability_public_tcp_failed: 0,
+        reachability_vmn_udp_success: 3,
+        reachability_vmn_udp_failed: 1,
+        reachability_vmn_tcp_success: 1,
+        reachability_vmn_tcp_failed: 3,
+      }
+    );
+  });
+});