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,34 @@ export default class Meeting extends StatelessWebexPlugin {
     if (mediaServer) {
       this.mediaProperties.webrtcMediaConnection.mediaServer = mediaServer;
     }
+
+    if (this.isMultistream && mediaServerIp) {
+      this.mediaServerIp = mediaServerIp;
+    }
+
+    // console.log('mediaServerIp: ', mediaServerIp);
+
+    // if (this.isMultistream && roapMessage.messageType === 'ANSWER') {
+    //   console.log('Processing answer!!!');
+
+    //   const candidate_regex = /^a=candidate:.*$/gm;
+
+    //   const candidateLines = roapMessage.sdp.match(candidate_regex) || [];
+
+    //   console.log('Candidate lines:', candidateLines);
+
+    //   try {
+    //     const ip_regex = /a=candidate:\d+ \d+ \w+ \d+ ([\d.]+) \d+ typ \w+/;
+
+    //     const udp_ice_candidate = candidateLines.find((line) => line.includes('UDP'));
+
+    //     // a=candidate:0 1 UDP 2130706431 144.196.73.28 5004 typ host
+    //     const candidate_ip = udp_ice_candidate.match(ip_regex)?.[1];
+    //     console.log('Candidate IP:', candidate_ip);
+    //   } catch (error) {
+    //     console.error('Error extracting candidate IP:', error);
+    //   }
+    // }
   };
 
   /**
@@ -7741,13 +7784,20 @@ 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(),
         connectionType,
         selectedCandidatePairChanges,
         numTransports,
         isMultistream: this.isMultistream,
+        // @ts-ignore
+        isSubnetReachable,
         retriedWithTurnServer: this.addMediaData.retriedWithTurnServer,
         isJoinWithMediaRetry: this.joinWithMediaRetryInfo.isRetry,
         ...reachabilityStats,

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;
+  public reachedSubnets: string[] = [];
 
   /**
    * 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.push(serverIp);
+    }
   }
 
   /**
@@ -350,15 +361,40 @@ export class ClusterReachability extends EventsScope {
       const latencyInMilliseconds = this.getElapsedTime();
 
       if (e.candidate) {
+        // const url = '';
+        // if ('url' in e.candidate) {
+        //   const candidate = e.candidate as any;
+
+        //   // url = candidate.url;
+
+        //   console.log(`Candidate: `, candidate);
+        //   // eslint-disable-next-line dot-notation
+        //   console.log(`Url: `, candidate['url']);
+
+        //   // eslint-disable-next-line dot-notation
+        //   console.log(`Url[dot]: `, candidate.url);
+        // }
+
         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);
+          this.saveResult(protocol, latencyInMilliseconds, null, e.candidate.address);
           // 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
         }

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

@@ -138,6 +138,28 @@ export default class Reachability extends EventsScope {
     }
   }
 
+  /**
+   * Checks if the given subnet is reachable
+   * @param {string} selectedCluster - cluster to check
+   * @param {string} subnet - subnet to check
+   * @returns {boolean} true if reachable, false otherwise
+   * @public
+   * @memberof Reachability
+   */
+  public isSubnetReachable(selectedCluster: string, subnet: string): boolean {
+    const cluster = Object.values(this.clusterReachability).find((c) =>
+      c.name.startsWith(selectedCluster)
+    );
+
+    if (!cluster) {
+      return false;
+    }
+
+    const subnetFirstOctet = subnet.split('.')[0];
+
+    return !!cluster.reachedSubnets.find((ss) => ss.startsWith(subnetFirstOctet));
+  }
+
   /**
    * 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