feat: metrics on reachability subnet

Author: k-wasniowski

packages/@webex/plugin-meetings/src/meeting/index.ts

@@ -722,6 +722,7 @@ export default class Meeting extends StatelessWebexPlugin {
   private rtcMetrics?: RtcMetrics;
   private uploadLogsTimer?: ReturnType<typeof setTimeout>;
   private logUploadIntervalIndex: number;
+  private mediaServerIp: string;
 
   /**
    * @param {Object} attrs
@@ -1598,6 +1599,15 @@ export default class Meeting extends StatelessWebexPlugin {
      * @memberof Meeting
      */
     this.#isoLocalClientMeetingJoinTime = undefined;
+
+    /**
+     * IP Address of remote media server
+     * @instance
+     * @type {number}
+     * @private
+     * @memberof Meeting
+     */
+    this.mediaServerIp = null;
   }
 
   /**
@@ -6329,6 +6339,11 @@ export default class Meeting extends StatelessWebexPlugin {
         ? MeetingsUtil.getMediaServer(roapMessage.sdp)
         : undefined;
 
+    const mediaServerIp =
+      roapMessage.messageType === 'ANSWER'
+        ? MeetingsUtil.getMediaServerIp(roapMessage.sdp)
+        : undefined;
+
     if (this.isMultistream && mediaServer && mediaServer !== 'homer') {
       throw new MultistreamNotSupportedError(
         `Client asked for multistream backend (Homer), but got ${mediaServer} instead`
@@ -6339,6 +6354,10 @@ export default class Meeting extends StatelessWebexPlugin {
     if (mediaServer) {
       this.mediaProperties.webrtcMediaConnection.mediaServer = mediaServer;
     }
+
+    if (this.isMultistream && mediaServerIp) {
+      this.mediaServerIp = mediaServerIp;
+    }
   };
 
   /**
@@ -7741,6 +7760,11 @@ export default class Meeting extends StatelessWebexPlugin {
       const reachabilityStats = await this.webex.meetings.reachability.getReachabilityMetrics();
       const iceCandidateErrors = Object.fromEntries(this.iceCandidateErrors);
 
+      const isSubnetReachable = this.getWebexObject().meetings.reachability.isSubnetReachable(
+        this.mediaConnections[0]?.mediaAgentCluster,
+        this.mediaServerIp
+      );
+
       Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADD_MEDIA_SUCCESS, {
         correlation_id: this.correlationId,
         locus_id: this.locusUrl.split('/').pop(),
@@ -7750,6 +7774,7 @@ export default class Meeting extends StatelessWebexPlugin {
         isMultistream: this.isMultistream,
         retriedWithTurnServer: this.addMediaData.retriedWithTurnServer,
         isJoinWithMediaRetry: this.joinWithMediaRetryInfo.isRetry,
+        isSubnetReachable,
         ...reachabilityStats,
         ...iceCandidateErrors,
         iceCandidatesCount: this.iceCandidatesCount,
@@ -7779,6 +7804,11 @@ export default class Meeting extends StatelessWebexPlugin {
 
       const iceCandidateErrors = Object.fromEntries(this.iceCandidateErrors);
 
+      const isSubnetReachable = this.getWebexObject().meetings.reachability.isSubnetReachable(
+        this.mediaConnections[0]?.mediaAgentCluster,
+        this.mediaServerIp
+      );
+
       Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE, {
         correlation_id: this.correlationId,
         locus_id: this.locusUrl.split('/').pop(),
@@ -7808,6 +7838,7 @@ export default class Meeting extends StatelessWebexPlugin {
           this.mediaProperties.webrtcMediaConnection?.mediaConnection?.pc?.iceConnectionState ||
           'unknown',
         ...reachabilityMetrics,
+        isSubnetReachable,
         ...iceCandidateErrors,
         iceCandidatesCount: this.iceCandidatesCount,
       });

packages/@webex/plugin-meetings/src/meetings/util.ts

@@ -99,6 +99,28 @@ MeetingsUtil.getMediaServer = (sdp) => {
   return mediaServer;
 };
 
+MeetingsUtil.getMediaServerIp = (sdp) => {
+  let mediaServerIp;
+
+  // Attempt to collect the media server from the roap message.
+  try {
+    mediaServerIp = sdp
+      .split('\r\n')
+      .find(
+        (line) =>
+          // Make sure we non-FQDN
+          line.startsWith('a=candidate') && line.includes('UDP') && !line.includes('webex.com')
+      )
+      .match(/a=candidate:\d+ \d+ \w+ \d+ ([\d.]+) \d+ typ \w+/)?.[1]
+      .toLowerCase()
+      .trim();
+  } catch {
+    mediaServerIp = undefined;
+  }
+
+  return mediaServerIp;
+};
+
 MeetingsUtil.checkForCorrelationId = (deviceUrl, locus) => {
   let devices = [];
 

packages/@webex/plugin-meetings/src/reachability/clusterReachability.ts

@@ -49,6 +49,7 @@ export class ClusterReachability extends EventsScope {
   private srflxIceCandidates: RTCIceCandidate[] = [];
   public readonly isVideoMesh: boolean;
   public readonly name;
+  private reachedSubnets: Set<string> = new Set();
 
   /**
    * Constructor for ClusterReachability
@@ -264,9 +265,15 @@ export class ClusterReachability extends EventsScope {
    * @param {string} protocol
    * @param {number} latency
    * @param {string|null} [publicIp]
+   * @param {string|null} [serverIp]
    * @returns {void}
    */
-  private saveResult(protocol: 'udp' | 'tcp' | 'xtls', latency: number, publicIp?: string | null) {
+  private saveResult(
+    protocol: 'udp' | 'tcp' | 'xtls',
+    latency: number,
+    publicIp?: string | null,
+    serverIp?: string | null
+  ) {
     const result = this.result[protocol];
 
     if (result.latencyInMilliseconds === undefined) {
@@ -294,6 +301,10 @@ export class ClusterReachability extends EventsScope {
     } else {
       this.addPublicIP(protocol, publicIp);
     }
+
+    if (serverIp) {
+      this.reachedSubnets.add(serverIp);
+    }
   }
 
   /**
@@ -351,16 +362,25 @@ export class ClusterReachability extends EventsScope {
 
       if (e.candidate) {
         if (e.candidate.type === CANDIDATE_TYPES.SERVER_REFLEXIVE) {
-          this.saveResult('udp', latencyInMilliseconds, e.candidate.address);
+          let serverIp = null;
+          if ('url' in e.candidate) {
+            const regex = /stun:([\d.]+):\d+/;
+
+            const match = (e.candidate as any).url.match(regex);
+            if (match) {
+              // eslint-disable-next-line prefer-destructuring
+              serverIp = match[1];
+            }
+          }
+
+          this.saveResult('udp', latencyInMilliseconds, e.candidate.address, serverIp);
 
           this.determineNatType(e.candidate);
         }
 
         if (e.candidate.type === CANDIDATE_TYPES.RELAY) {
           const protocol = e.candidate.port === TURN_TLS_PORT ? 'xtls' : 'tcp';
-          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
+          this.saveResult(protocol, latencyInMilliseconds, null, e.candidate.address);
         }
 
         if (this.haveWeGotAllResults()) {
@@ -429,4 +449,28 @@ export class ClusterReachability extends EventsScope {
 
     return this.defer.promise;
   }
+
+  /**
+   * Checks if the media server is reachable
+   * @param {boolean} mediaServerIp - media server ip
+   * @returns {boolean} true if reachable, false otherwise
+   */
+  public isMediaServerReachable(mediaServerIp: string): boolean {
+    const subnetFirstOctet = mediaServerIp.split('.')[0];
+
+    const foundSubnet = Array.from(this.reachedSubnets).find((reachedSubnet) =>
+      reachedSubnet.startsWith(subnetFirstOctet)
+    );
+
+    if (!foundSubnet) {
+      let errorMessage = `Reachability:ClusterReachability#isSubnetReachable --> Subnet ${subnetFirstOctet} in ${this.name} is not reachable, reached subnets: \n`;
+      this.reachedSubnets.forEach((s) => {
+        errorMessage += `\t${s}\n`;
+      });
+
+      LoggerProxy.logger.error(errorMessage);
+    }
+
+    return !!foundSubnet;
+  }
 }

packages/@webex/plugin-meetings/src/reachability/index.ts

@@ -138,6 +138,26 @@ export default class Reachability extends EventsScope {
     }
   }
 
+  /**
+   * Checks if the given subnet is reachable
+   * @param {string} selectedCluster - cluster to check
+   * @param {string} mediaServerIp - media server ip
+   * @returns {boolean} true if reachable, false otherwise
+   * @public
+   * @memberof Reachability
+   */
+  public isSubnetReachable(selectedCluster: string, mediaServerIp: string): boolean {
+    const cluster = Object.values(this.clusterReachability).find((c) =>
+      c.name.startsWith(selectedCluster)
+    );
+
+    if (!cluster) {
+      return false;
+    }
+
+    return cluster.isMediaServerReachable(mediaServerIp);
+  }
+
   /**
    * Gets a list of media clusters from the backend and performs reachability checks on all the clusters
    * @param {string} trigger - explains the reason for starting reachability