@webex/internal-plugin-metrics 3.8.1-next.12 → 3.8.1-next.14

package/src/call-diagnostic/call-diagnostic-metrics-latencies.ts

@@ -148,15 +148,27 @@ export default class CallDiagnosticLatencies extends WebexPlugin {
    * @param b end
    * @returns latency
    */
-  public getDiffBetweenTimestamps(a: MetricEventNames, b: MetricEventNames) {
+  public getDiffBetweenTimestamps(
+    a: MetricEventNames,
+    b: MetricEventNames,
+    clampValues?: {minimum?: number; maximum?: number}
+  ) {
     const start = this.latencyTimestamps.get(a);
     const end = this.latencyTimestamps.get(b);
 
-    if (typeof start === 'number' && typeof end === 'number') {
-      return end - start;
+    if (typeof start !== 'number' || typeof end !== 'number') {
+      return undefined;
     }
 
-    return undefined;
+    const diff = end - start;
+
+    if (!clampValues) {
+      return diff;
+    }
+
+    const {minimum = 0, maximum} = clampValues;
+
+    return Math.min(maximum ?? Infinity, Math.max(diff, minimum));
   }
 
   /**
@@ -172,7 +184,8 @@ export default class CallDiagnosticLatencies extends WebexPlugin {
   public getMeetingInfoReqResp() {
     return this.getDiffBetweenTimestamps(
       'internal.client.meetinginfo.request',
-      'internal.client.meetinginfo.response'
+      'internal.client.meetinginfo.response',
+      {maximum: 1200000}
     );
   }
 
@@ -215,7 +228,8 @@ export default class CallDiagnosticLatencies extends WebexPlugin {
   public getCallInitJoinReq() {
     return this.getDiffBetweenTimestamps(
       'internal.client.interstitial-window.click.joinbutton',
-      'client.locus.join.request'
+      'client.locus.join.request',
+      {maximum: 1200000}
     );
   }
 
@@ -224,7 +238,11 @@ export default class CallDiagnosticLatencies extends WebexPlugin {
    * @returns - latency
    */
   public getJoinReqResp() {
-    return this.getDiffBetweenTimestamps('client.locus.join.request', 'client.locus.join.response');
+    return this.getDiffBetweenTimestamps(
+      'client.locus.join.request',
+      'client.locus.join.response',
+      {maximum: 1200000}
+    );
   }
 
   /**
@@ -245,7 +263,8 @@ export default class CallDiagnosticLatencies extends WebexPlugin {
   public getLocalSDPGenRemoteSDPRecv() {
     return this.getDiffBetweenTimestamps(
       'client.media-engine.local-sdp-generated',
-      'client.media-engine.remote-sdp-received'
+      'client.media-engine.remote-sdp-received',
+      {maximum: 1200000}
     );
   }
 
@@ -254,7 +273,7 @@ export default class CallDiagnosticLatencies extends WebexPlugin {
    * @returns - latency
    */
   public getICESetupTime() {
-    return this.getDiffBetweenTimestamps('client.ice.start', 'client.ice.end');
+    return this.getDiffBetweenTimestamps('client.ice.start', 'client.ice.end', {maximum: 1200000});
   }
 
   /**
@@ -378,7 +397,8 @@ export default class CallDiagnosticLatencies extends WebexPlugin {
   public getCallInitMediaEngineReady() {
     return this.getDiffBetweenTimestamps(
       'internal.client.interstitial-window.click.joinbutton',
-      'client.media-engine.ready'
+      'client.media-engine.ready',
+      {maximum: 1200000}
     );
   }
 
@@ -398,7 +418,9 @@ export default class CallDiagnosticLatencies extends WebexPlugin {
     const lobbyTime = typeof lobbyTimeLatency === 'number' ? lobbyTimeLatency : 0;
 
     if (interstitialJoinClickTimestamp && connectedMedia) {
-      return connectedMedia - interstitialJoinClickTimestamp - lobbyTime;
+      const interstitialToMediaOKJmt = connectedMedia - interstitialJoinClickTimestamp - lobbyTime;
+
+      return Math.max(0, interstitialToMediaOKJmt);
     }
 
     return undefined;
@@ -463,12 +485,12 @@ export default class CallDiagnosticLatencies extends WebexPlugin {
     const lobbyTime = this.getStayLobbyTime();
 
     if (clickToInterstitial && interstitialToJoinOk && joinConfJMT) {
-      const totalMediaJMT = clickToInterstitial + interstitialToJoinOk + joinConfJMT;
+      const totalMediaJMT = Math.max(0, clickToInterstitial + interstitialToJoinOk + joinConfJMT);
       if (this.getMeeting()?.allowMediaInLobby) {
         return totalMediaJMT;
       }
 
-      return totalMediaJMT - lobbyTime;
+      return Math.max(0, totalMediaJMT - lobbyTime);
     }
 
     return undefined;
@@ -484,7 +506,7 @@ export default class CallDiagnosticLatencies extends WebexPlugin {
     const joinConfJMT = this.getJoinConfJMT();
 
     if (clickToInterstitialWithUserDelay && interstitialToJoinOk && joinConfJMT) {
-      return clickToInterstitialWithUserDelay + interstitialToJoinOk + joinConfJMT;
+      return Math.max(0, clickToInterstitialWithUserDelay + interstitialToJoinOk + joinConfJMT);
     }
 
     return undefined;
@@ -499,7 +521,7 @@ export default class CallDiagnosticLatencies extends WebexPlugin {
     const joinConfJMT = this.getJoinConfJMT();
 
     if (typeof interstitialToJoinOk === 'number' && typeof joinConfJMT === 'number') {
-      return interstitialToJoinOk - joinConfJMT;
+      return Math.max(0, interstitialToJoinOk - joinConfJMT);
     }
 
     return undefined;

package/src/call-diagnostic/call-diagnostic-metrics.ts

@@ -105,6 +105,8 @@ export default class CallDiagnosticMetrics extends StatelessWebexPlugin {
   private delayedClientFeatureEvents: DelayedClientFeatureEvent[] = [];
   private eventErrorCache: WeakMap<any, any> = new WeakMap();
   private isMercuryConnected = false;
+  private eventLimitTracker: Map<string, number> = new Map();
+  private eventLimitWarningsLogged: Set<string> = new Set();
 
   // the default validator before piping an event to the batcher
   // this function can be overridden by the user
@@ -665,6 +667,144 @@ export default class CallDiagnosticMetrics extends StatelessWebexPlugin {
     this.eventErrorCache = new WeakMap();
   }
 
+  /**
+   * Checks if an event should be limited based on criteria defined in the event dictionary.
+   * Returns true if the event should be sent, false if it has reached its limit.
+   * @param event - The diagnostic event object
+   * @returns boolean indicating whether the event should be sent
+   */
+  private shouldSendEvent({event}: Event): boolean {
+    const eventName = event?.name as string;
+    const correlationId = event?.identifiers?.correlationId;
+
+    if (!correlationId || correlationId === 'unknown') {
+      return true;
+    }
+
+    const limitKeyPrefix = `${eventName}:${correlationId}`;
+
+    switch (eventName) {
+      case 'client.media.render.start':
+      case 'client.media.render.stop':
+      case 'client.media.rx.start':
+      case 'client.media.rx.stop':
+      case 'client.media.tx.start':
+      case 'client.media.tx.stop': {
+        // Send only once per mediaType-correlationId pair (or mediaType-correlationId-shareInstanceId for share/share_audio)
+        const mediaType = event?.mediaType;
+        if (mediaType) {
+          if (mediaType === 'share' || mediaType === 'share_audio') {
+            const shareInstanceId = event?.shareInstanceId;
+            if (shareInstanceId) {
+              const limitKey = `${limitKeyPrefix}:${mediaType}:${shareInstanceId}`;
+
+              return this.checkAndIncrementEventCount(
+                limitKey,
+                1,
+                `${eventName} for ${mediaType} instance ${shareInstanceId}`
+              );
+            }
+          } else {
+            const limitKey = `${limitKeyPrefix}:${mediaType}`;
+
+            return this.checkAndIncrementEventCount(
+              limitKey,
+              1,
+              `${eventName} for mediaType ${mediaType}`
+            );
+          }
+        }
+        break;
+      }
+
+      case 'client.roap-message.received':
+      case 'client.roap-message.sent': {
+        // Send only once per correlationId and roap.messageType/roap.type
+        const roapMessageType = event?.roap?.messageType || event?.roap?.type;
+        if (roapMessageType) {
+          const limitKey = `${limitKeyPrefix}:${roapMessageType}`;
+
+          return this.checkAndIncrementEventCount(
+            limitKey,
+            1,
+            `${eventName} for ROAP type ${roapMessageType}`
+          );
+        }
+        break;
+      }
+
+      default:
+        return true;
+    }
+
+    return true;
+  }
+
+  /**
+   * Checks the current count for a limit key and increments if under limit.
+   * @param limitKey - The unique key for this limit combination
+   * @param maxCount - Maximum allowed count
+   * @param eventDescription - Description for logging
+   * @returns true if under limit and incremented, false if at/over limit
+   */
+  private checkAndIncrementEventCount(
+    limitKey: string,
+    maxCount: number,
+    eventDescription: string
+  ): boolean {
+    const currentCount = this.eventLimitTracker.get(limitKey) || 0;
+
+    if (currentCount >= maxCount) {
+      // Log warning only once per limit key
+      if (!this.eventLimitWarningsLogged.has(limitKey)) {
+        this.logger.log(
+          CALL_DIAGNOSTIC_LOG_IDENTIFIER,
+          `CallDiagnosticMetrics: Event limit reached for ${eventDescription}. ` +
+            `Max count ${maxCount} exceeded. Event will not be sent.`,
+          `limitKey: ${limitKey}`
+        );
+        this.eventLimitWarningsLogged.add(limitKey);
+      }
+
+      return false;
+    }
+
+    // Increment count and allow event
+    this.eventLimitTracker.set(limitKey, currentCount + 1);
+
+    return true;
+  }
+
+  /**
+   * Clears event limit tracking
+   */
+  public clearEventLimits(): void {
+    this.eventLimitTracker.clear();
+    this.eventLimitWarningsLogged.clear();
+  }
+
+  /**
+   * Clears event limit tracking for a specific correlationId only.
+   * Keeps limits for other meetings intact.
+   */
+  public clearEventLimitsForCorrelationId(correlationId: string): void {
+    if (!correlationId) {
+      return;
+    }
+    // Keys are formatted as "eventName:correlationId:..." across all limiters.
+    const hasCorrIdAtSecondToken = (key: string) => key.split(':')[1] === correlationId;
+    for (const key of Array.from(this.eventLimitTracker.keys())) {
+      if (hasCorrIdAtSecondToken(key)) {
+        this.eventLimitTracker.delete(key);
+      }
+    }
+    for (const key of Array.from(this.eventLimitWarningsLogged.values())) {
+      if (hasCorrIdAtSecondToken(key)) {
+        this.eventLimitWarningsLogged.delete(key);
+      }
+    }
+  }
+
   /**
    * Generate error payload for Client Event
    * @param rawError
@@ -1099,6 +1239,10 @@ export default class CallDiagnosticMetrics extends StatelessWebexPlugin {
     );
     const diagnosticEvent = this.prepareClientEvent({name, payload, options});
 
+    if (!this.shouldSendEvent(diagnosticEvent)) {
+      return Promise.resolve();
+    }
+
     if (options?.preLoginId) {
       return this.submitToCallDiagnosticsPreLogin(diagnosticEvent, options?.preLoginId);
     }

package/test/unit/spec/call-diagnostic/call-diagnostic-metrics-latencies.ts

@@ -130,6 +130,82 @@ describe('internal-plugin-metrics', () => {
       assert.deepEqual(res2, undefined);
     });
 
+    describe('getDiffBetweenTimestamps with clamping', () => {
+      it('should return diff without clamping when no clampValues provided', () => {
+        cdl.saveTimestamp({key: 'client.alert.displayed', value: 10});
+        cdl.saveTimestamp({key: 'client.alert.removed', value: 50});
+        const res = cdl.getDiffBetweenTimestamps('client.alert.displayed', 'client.alert.removed');
+        assert.deepEqual(res, 40);
+      });
+
+      it('should return diff without clamping when value is within range', () => {
+        cdl.saveTimestamp({key: 'client.alert.displayed', value: 10});
+        cdl.saveTimestamp({key: 'client.alert.removed', value: 50});
+        const res = cdl.getDiffBetweenTimestamps('client.alert.displayed', 'client.alert.removed', {
+          minimum: 0,
+          maximum: 100
+        });
+        assert.deepEqual(res, 40);
+      });
+
+      it('should clamp to minimum when diff is below minimum', () => {
+        cdl.saveTimestamp({key: 'client.alert.displayed', value: 50});
+        cdl.saveTimestamp({key: 'client.alert.removed', value: 45});
+        const res = cdl.getDiffBetweenTimestamps('client.alert.displayed', 'client.alert.removed', {
+          minimum: 10,
+          maximum: 100
+        });
+        assert.deepEqual(res, 10);
+      });
+
+      it('should clamp to maximum when diff is above maximum', () => {
+        cdl.saveTimestamp({key: 'client.alert.displayed', value: 10});
+        cdl.saveTimestamp({key: 'client.alert.removed', value: 210});
+        const res = cdl.getDiffBetweenTimestamps('client.alert.displayed', 'client.alert.removed', {
+          minimum: 0,
+          maximum: 100
+        });
+        assert.deepEqual(res, 100);
+      });
+
+      it('should use default minimum of 0 when only maximum is specified', () => {
+        cdl.saveTimestamp({key: 'client.alert.displayed', value: 50});
+        cdl.saveTimestamp({key: 'client.alert.removed', value: 45});
+        const res = cdl.getDiffBetweenTimestamps('client.alert.displayed', 'client.alert.removed', {
+          maximum: 100
+        });
+        assert.deepEqual(res, 0);
+      });
+
+      it('should not clamp maximum when maximum is undefined', () => {
+        cdl.saveTimestamp({key: 'client.alert.displayed', value: 10});
+        cdl.saveTimestamp({key: 'client.alert.removed', value: 2000});
+        const res = cdl.getDiffBetweenTimestamps('client.alert.displayed', 'client.alert.removed', {
+          minimum: 5
+        });
+        assert.deepEqual(res, 1990);
+      });
+
+      it('should handle negative differences correctly with clamping', () => {
+        cdl.saveTimestamp({key: 'client.alert.displayed', value: 100});
+        cdl.saveTimestamp({key: 'client.alert.removed', value: 50});
+        const res = cdl.getDiffBetweenTimestamps('client.alert.displayed', 'client.alert.removed', {
+          minimum: 10,
+          maximum: 1000
+        });
+        assert.deepEqual(res, 10);
+      });
+
+      it('should return undefined when timestamps are missing even with clamping', () => {
+        cdl.saveTimestamp({key: 'client.alert.displayed', value: 10});
+        const res = cdl.getDiffBetweenTimestamps('client.alert.displayed', 'client.alert.removed', {
+          minimum: 0,
+          maximum: 100
+        });
+        assert.deepEqual(res, undefined);
+      });
+    });
+
     it('calculates getMeetingInfoReqResp correctly', () => {
       cdl.saveTimestamp({key: 'internal.client.meetinginfo.request', value: 10});
       cdl.saveTimestamp({key: 'internal.client.meetinginfo.response', value: 20});