@webex/plugin-meetings 3.3.1-next.2 → 3.3.1-next.21

package/src/meeting/index.ts

@@ -153,6 +153,7 @@ import RecordingController from '../recording-controller';
 import ControlsOptionsManager from '../controls-options-manager';
 import PermissionError from '../common/errors/permission';
 import {LocusMediaRequest} from './locusMediaRequest';
+import {ConnectionStateHandler, ConnectionStateEvent} from './connectionStateHandler';
 
 const logRequest = (request: any, {logText = ''}) => {
   LoggerProxy.logger.info(`${logText} - sending request`);
@@ -680,6 +681,8 @@ export default class Meeting extends StatelessWebexPlugin {
   private sdpResponseTimer?: ReturnType<typeof setTimeout>;
   private hasMediaConnectionConnectedAtLeastOnce: boolean;
   private joinWithMediaRetryInfo?: {isRetry: boolean; prevJoinResponse?: any};
+  private connectionStateHandler?: ConnectionStateHandler;
+  private iceCandidateErrors: Map<string, number>;
 
   /**
    * @param {Object} attrs
@@ -1470,6 +1473,24 @@ export default class Meeting extends StatelessWebexPlugin {
      * @memberof Meeting
      */
     this.joinWithMediaRetryInfo = {isRetry: false, prevJoinResponse: undefined};
+
+    /**
+     * Connection state handler
+     * @instance
+     * @type {ConnectionStateHandler}
+     * @private
+     * @memberof Meeting
+     */
+    this.connectionStateHandler = undefined;
+
+    /**
+     * ICE Candidates errors map
+     * @instance
+     * @type {Map<[number, string], number>}
+     * @private
+     * @memberof Meeting
+     */
+    this.iceCandidateErrors = new Map();
   }
 
   /**
@@ -5233,8 +5254,13 @@ export default class Meeting extends StatelessWebexPlugin {
 
     // @ts-ignore - Fix type
     if (this.webex.internal.llm.isConnected()) {
-      // @ts-ignore - Fix type
-      if (url === this.webex.internal.llm.getLocusUrl() && isJoined) {
+      if (
+        // @ts-ignore - Fix type
+        url === this.webex.internal.llm.getLocusUrl() &&
+        // @ts-ignore - Fix type
+        datachannelUrl === this.webex.internal.llm.getDatachannelUrl() &&
+        isJoined
+      ) {
         return undefined;
       }
       // @ts-ignore - Fix type
@@ -5846,7 +5872,11 @@ export default class Meeting extends StatelessWebexPlugin {
       }
     });
 
-    this.mediaProperties.webrtcMediaConnection.on(Event.CONNECTION_STATE_CHANGED, (event) => {
+    this.connectionStateHandler = new ConnectionStateHandler(
+      this.mediaProperties.webrtcMediaConnection
+    );
+
+    this.connectionStateHandler.on(ConnectionStateEvent.stateChanged, (event) => {
       const connectionFailed = () => {
         Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.CONNECTION_FAILURE, {
           correlation_id: this.correlationId,
@@ -5990,6 +6020,32 @@ export default class Meeting extends StatelessWebexPlugin {
         );
       }
     );
+
+    this.iceCandidateErrors.clear();
+    this.mediaProperties.webrtcMediaConnection.on(Event.ICE_CANDIDATE_ERROR, (event) => {
+      const {errorCode} = event.error;
+      let {errorText} = event.error;
+
+      if (
+        errorCode === 600 &&
+        errorText === 'Address not associated with the desired network interface.'
+      ) {
+        return;
+      }
+
+      if (errorText.endsWith('.')) {
+        errorText = errorText.slice(0, -1);
+      }
+
+      errorText = errorText.toLowerCase();
+      errorText = errorText.replace(/ /g, '_');
+
+      const error = `${errorCode}_${errorText}`;
+
+      const count = this.iceCandidateErrors.get(error) || 0;
+
+      this.iceCandidateErrors.set(error, count + 1);
+    });
   };
 
   /**
@@ -6264,6 +6320,8 @@ export default class Meeting extends StatelessWebexPlugin {
     try {
       await this.mediaProperties.waitForMediaConnectionConnected();
     } catch (error) {
+      const {iceConnected} = error;
+
       if (!this.hasMediaConnectionConnectedAtLeastOnce) {
         // Only send CA event for join flow if we haven't successfully connected media yet
         // @ts-ignore
@@ -6283,12 +6341,7 @@ export default class Meeting extends StatelessWebexPlugin {
                       this.mediaProperties.webrtcMediaConnection?.mediaConnection?.pc
                         ?.signalingState ||
                       'unknown',
-                    iceConnectionState:
-                      this.mediaProperties.webrtcMediaConnection?.multistreamConnection?.pc?.pc
-                        ?.iceConnectionState ||
-                      this.mediaProperties.webrtcMediaConnection?.mediaConnection?.pc
-                        ?.iceConnectionState ||
-                      'unknown',
+                    iceConnected,
                     turnServerUsed: this.turnServerUsed,
                   }),
                 }
@@ -6317,12 +6370,13 @@ export default class Meeting extends StatelessWebexPlugin {
     if (this.config.stats.enableStatsAnalyzer) {
       // @ts-ignore - config coming from registerPlugin
       this.networkQualityMonitor = new NetworkQualityMonitor(this.config.stats);
-      this.statsAnalyzer = new StatsAnalyzer(
+      this.statsAnalyzer = new StatsAnalyzer({
         // @ts-ignore - config coming from registerPlugin
-        this.config.stats,
-        (ssrc: number) => this.receiveSlotManager.findReceiveSlotBySsrc(ssrc),
-        this.networkQualityMonitor
-      );
+        config: this.config.stats,
+        receiveSlotCallback: (ssrc: number) => this.receiveSlotManager.findReceiveSlotBySsrc(ssrc),
+        networkQualityMonitor: this.networkQualityMonitor,
+        isMultistream: this.isMultistream,
+      });
       this.setupStatsAnalyzerEventHandlers();
       this.networkQualityMonitor.on(
         EVENT_TRIGGERS.NETWORK_QUALITY,
@@ -6830,6 +6884,8 @@ export default class Meeting extends StatelessWebexPlugin {
       const {selectedCandidatePairChanges, numTransports} =
         await this.mediaProperties.getCurrentConnectionInfo();
 
+      const iceCandidateErrors = Object.fromEntries(this.iceCandidateErrors);
+
       Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE, {
         correlation_id: this.correlationId,
         locus_id: this.locusUrl.split('/').pop(),
@@ -6859,6 +6915,7 @@ export default class Meeting extends StatelessWebexPlugin {
           this.mediaProperties.webrtcMediaConnection?.mediaConnection?.pc?.iceConnectionState ||
           'unknown',
         ...reachabilityMetrics,
+        ...iceCandidateErrors,
       });
 
       await this.cleanUpOnAddMediaFailure();
@@ -7896,6 +7953,7 @@ export default class Meeting extends StatelessWebexPlugin {
     Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETING_SHARE_VIDEO_MUTE_STATE_CHANGE, {
       correlationId: this.correlationId,
       muted,
+      encoderImplementation: this.statsAnalyzer?.shareVideoEncoderImplementation,
     });
   };
 

package/src/metrics/constants.ts

@@ -69,6 +69,7 @@ const BEHAVIORAL_METRICS = {
   ROAP_OFFER_TO_ANSWER_LATENCY: 'js_sdk_roap_offer_to_answer_latency',
   ROAP_HTTP_RESPONSE_MISSING: 'js_sdk_roap_http_response_missing',
   TURN_DISCOVERY_REQUIRES_OK: 'js_sdk_turn_discovery_requires_ok',
+  REACHABILITY_COMPLETED: 'js_sdk_reachability_completed',
 };
 
 export {BEHAVIORAL_METRICS as default};

package/src/metrics/index.ts

@@ -65,6 +65,50 @@ class Metrics {
       tags: metricTags,
     });
   }
+
+  /**
+   * Flattens an object into one that has no nested properties. Each level of nesting is represented
+   * by "_" in the flattened object property names.
+   * This function is needed, because Amplitude doesn't allow passing nested objects as metricFields.
+   * Use this function for metricFields before calling sendBehavioralMetric() if you want to send
+   * nested objects in your metrics.
+   *
+   * If the function is called with a literal, it returns an object with a single property "value"
+   * and the literal value in it.
+   *
+   * @param {any} payload object you want to flatten
+   * @param {string} prefix string prefix prepended to any property names in flatten object
+   * @returns {Object}
+   */
+  prepareMetricFields(payload: any = {}, prefix = '') {
+    let output = {};
+
+    if (Array.isArray(payload)) {
+      payload.forEach((item, index) => {
+        const propName = prefix.length > 0 ? `${prefix}_${index}` : `${index}`;
+
+        output = {...output, ...this.prepareMetricFields(item, propName)};
+      });
+
+      return output;
+    }
+
+    if (typeof payload !== 'object' || payload === null) {
+      if (prefix.length > 0) {
+        return {[prefix]: payload};
+      }
+
+      return {value: payload};
+    }
+
+    Object.entries(payload).forEach(([key, value]) => {
+      const propName = prefix.length > 0 ? `${prefix}_${key}` : key;
+
+      output = {...output, ...this.prepareMetricFields(value, propName)};
+    });
+
+    return output;
+  }
 }
 
 // Export Metrics singleton ---------------------------------------------------

package/src/reachability/clusterReachability.ts

@@ -3,11 +3,9 @@ import {Defer} from '@webex/common';
 import LoggerProxy from '../common/logs/logger-proxy';
 import {ClusterNode} from './request';
 import {convertStunUrlToTurn, convertStunUrlToTurnTls} from './util';
+import EventsScope from '../common/events/events-scope';
 
-import {ICE_GATHERING_STATE, CONNECTION_STATE} from '../constants';
-
-const DEFAULT_TIMEOUT = 3000;
-const VIDEO_MESH_TIMEOUT = 1000;
+import {CONNECTION_STATE, Enum, ICE_GATHERING_STATE} from '../constants';
 
 // result for a specific transport protocol (like udp or tcp)
 export type TransportResult = {
@@ -23,10 +21,32 @@ export type ClusterReachabilityResult = {
   xtls: TransportResult;
 };
 
+// data for the Events.resultReady event
+export type ResultEventData = {
+  protocol: 'udp' | 'tcp' | 'xtls';
+  result: 'reachable' | 'unreachable' | 'untested';
+  latencyInMilliseconds: number; // amount of time it took to get the ICE candidate
+  clientMediaIPs?: string[];
+};
+
+// data for the Events.clientMediaIpsUpdated event
+export type ClientMediaIpsUpdatedEventData = {
+  protocol: 'udp' | 'tcp' | 'xtls';
+  clientMediaIPs: string[];
+};
+
+export const Events = {
+  resultReady: 'resultReady', // emitted when a cluster is reached successfully using specific protocol
+  clientMediaIpsUpdated: 'clientMediaIpsUpdated', // emitted when more public IPs are found after resultReady was already sent for a given protocol
+} as const;
+
+export type Events = Enum<typeof Events>;
+
 /**
  * A class that handles reachability checks for a single cluster.
+ * It emits events from Events enum
  */
-export class ClusterReachability {
+export class ClusterReachability extends EventsScope {
   private numUdpUrls: number;
   private numTcpUrls: number;
   private numXTlsUrls: number;
@@ -43,6 +63,7 @@ export class ClusterReachability {
    * @param {ClusterNode} clusterInfo information about the media cluster
    */
   constructor(name: string, clusterInfo: ClusterNode) {
+    super();
     this.name = name;
     this.isVideoMesh = clusterInfo.isVideoMesh;
     this.numUdpUrls = clusterInfo.udp.length;
@@ -162,23 +183,54 @@ export class ClusterReachability {
     this.defer.resolve();
   }
 
+  /**
+   * Aborts the cluster reachability checks by closing the peer connection
+   *
+   * @returns {void}
+   */
+  public abort() {
+    const {CLOSED} = CONNECTION_STATE;
+
+    if (this.pc.connectionState !== CLOSED) {
+      this.closePeerConnection();
+      this.finishReachabilityCheck();
+    }
+  }
+
   /**
    * Adds public IP (client media IPs)
    * @param {string} protocol
    * @param {string} publicIP
    * @returns {void}
    */
-  private addPublicIP(protocol: 'udp' | 'tcp', publicIP?: string | null) {
+  private addPublicIP(protocol: 'udp' | 'tcp' | 'xtls', publicIP?: string | null) {
     const result = this.result[protocol];
 
     if (publicIP) {
+      let ipAdded = false;
+
       if (result.clientMediaIPs) {
         if (!result.clientMediaIPs.includes(publicIP)) {
           result.clientMediaIPs.push(publicIP);
+          ipAdded = true;
         }
       } else {
         result.clientMediaIPs = [publicIP];
+        ipAdded = true;
       }
+
+      if (ipAdded)
+        this.emit(
+          {
+            file: 'clusterReachability',
+            function: 'addPublicIP',
+          },
+          Events.clientMediaIpsUpdated,
+          {
+            protocol,
+            clientMediaIPs: result.clientMediaIPs,
+          }
+        );
     }
   }
 
@@ -211,22 +263,43 @@ export class ClusterReachability {
   }
 
   /**
-   * Stores the latency in the result for the given protocol and marks it as reachable
+   * Saves the latency in the result for the given protocol and marks it as reachable,
+   * emits the "resultReady" event if this is the first result for that protocol,
+   * emits the "clientMediaIpsUpdated" event if we already had a result and only found
+   * a new client IP
    *
    * @param {string} protocol
    * @param {number} latency
+   * @param {string|null} [publicIp]
    * @returns {void}
    */
-  private storeLatencyResult(protocol: 'udp' | 'tcp' | 'xtls', latency: number) {
+  private saveResult(protocol: 'udp' | 'tcp' | 'xtls', latency: number, publicIp?: string | null) {
     const result = this.result[protocol];
 
     if (result.latencyInMilliseconds === undefined) {
       LoggerProxy.logger.log(
         // @ts-ignore
-        `Reachability:index#storeLatencyResult --> Successfully reached ${this.name} over ${protocol}: ${latency}ms`
+        `Reachability:index#saveResult --> Successfully reached ${this.name} over ${protocol}: ${latency}ms`
       );
       result.latencyInMilliseconds = latency;
       result.result = 'reachable';
+      if (publicIp) {
+        result.clientMediaIPs = [publicIp];
+      }
+
+      this.emit(
+        {
+          file: 'clusterReachability',
+          function: 'saveResult',
+        },
+        Events.resultReady,
+        {
+          protocol,
+          ...result,
+        }
+      );
+    } else {
+      this.addPublicIP(protocol, publicIp);
     }
   }
 
@@ -243,15 +316,16 @@ export class ClusterReachability {
         RELAY: 'relay',
       };
 
+      const latencyInMilliseconds = this.getElapsedTime();
+
       if (e.candidate) {
         if (e.candidate.type === CANDIDATE_TYPES.SERVER_REFLEXIVE) {
-          this.storeLatencyResult('udp', this.getElapsedTime());
-          this.addPublicIP('udp', e.candidate.address);
+          this.saveResult('udp', latencyInMilliseconds, e.candidate.address);
         }
 
         if (e.candidate.type === CANDIDATE_TYPES.RELAY) {
           const protocol = e.candidate.port === TURN_TLS_PORT ? 'xtls' : 'tcp';
-          this.storeLatencyResult(protocol, this.getElapsedTime());
+          this.saveResult(protocol, latencyInMilliseconds);
           // we don't add public IP for TCP, because in the case of relay candidates
           // e.candidate.address is the TURN server address, not the client's public IP
         }
@@ -314,22 +388,9 @@ export class ClusterReachability {
    * @returns {Promise} promise that's resolved once reachability checks for this cluster are completed or timeout is reached
    */
   private gatherIceCandidates() {
-    const timeout = this.isVideoMesh ? VIDEO_MESH_TIMEOUT : DEFAULT_TIMEOUT;
-
     this.registerIceGatheringStateChangeListener();
     this.registerIceCandidateListener();
 
-    // Set maximum timeout
-    setTimeout(() => {
-      const {CLOSED} = CONNECTION_STATE;
-
-      // Close any open peerConnections
-      if (this.pc.connectionState !== CLOSED) {
-        this.closePeerConnection();
-        this.finishReachabilityCheck();
-      }
-    }, timeout);
-
     return this.defer.promise;
   }
 }