@webex/internal-plugin-metrics 3.8.1-next.11 → 3.8.1-next.13

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/src/metrics.types.ts

@@ -160,7 +160,9 @@ export type InternalEvent = {
     | 'internal.client.meeting.interstitial-window.showed'
     | 'internal.client.interstitial-window.click.joinbutton'
     | 'internal.client.add-media.turn-discovery.start'
-    | 'internal.client.add-media.turn-discovery.end';
+    | 'internal.client.add-media.turn-discovery.end'
+    | 'internal.client.share.initiated'
+    | 'internal.client.share.stopped';
 
   payload?: never;
   options?: never;

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

@@ -918,6 +918,18 @@ describe('internal-plugin-metrics', () => {
       assert.deepEqual(cdl.getInterstitialToMediaOKJMT(), 10);
     });
 
+    it('calculates getShareDuration correctly', () => {
+      cdl.saveTimestamp({
+        key: 'internal.client.share.initiated',
+        value: 5,
+      });
+      cdl.saveTimestamp({
+        key: 'internal.client.share.stopped',
+        value: 7,
+      });
+      assert.deepEqual(cdl.getShareDuration(), 2);
+    });
+
     describe('calculates getU2CTime correctly', () => {
       it('returns undefined when no precomputed value available', () => {
         assert.deepEqual(cdl.getU2CTime(), undefined);

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

@@ -2431,7 +2431,7 @@ describe('internal-plugin-metrics', () => {
         );
       });
 
-      it('should send behavioral event if meetingId provided but meeting is undefined', () => {
+      it('should record failure metric when meetingId is provided but meeting is undefined', () => {
         webex.meetings.getBasicMeetingInformation = sinon.stub().returns(undefined);
 
         cd.submitClientEvent({name: 'client.alert.displayed', options: {meetingId: 'meetingId'}});
@@ -2465,6 +2465,228 @@ describe('internal-plugin-metrics', () => {
         assert.calledWith(cd.submitToCallDiagnosticsPreLogin, testEvent);
         assert.notCalled(cd.submitToCallDiagnostics);
       });
+
+      describe('Limiting repeated events', () => {
+        beforeEach(() => {
+          cd.clearEventLimits();
+        });
+
+        const createEventLimitRegex = (eventName: string, eventType: string) => {
+          const escapedEventName = eventName.replace(/\./g, '\\.');
+          return new RegExp(`Event limit reached for ${escapedEventName} for ${eventType}`);
+        };
+
+        it('should always send events that are not in the limiting switch cases', () => {
+          const options = {
+            meetingId: fakeMeeting.id,
+          };
+          const submitToCallDiagnosticsStub = sinon.stub(cd, 'submitToCallDiagnostics');
+
+          const baselineCallCount = webex.logger.log.callCount;
+          cd.submitClientEvent({
+            name: 'client.alert.displayed',
+            options,
+          });
+
+          cd.submitClientEvent({
+            name: 'client.alert.displayed',
+            options,
+          });
+
+          cd.submitClientEvent({
+            name: 'client.alert.displayed',
+            options,
+          });
+
+          assert.calledThrice(submitToCallDiagnosticsStub);
+          });
+
+        ([
+          ['client.media.render.start'],
+          ['client.media.render.stop'],
+          ['client.media.rx.start'],
+          ['client.media.rx.stop'],
+          ['client.media.tx.start'],
+          ['client.media.tx.stop']
+        ] as const).forEach(([name]) => {
+          it(`should only send ${name} once per mediaType`, () => {
+            const options = {
+              meetingId: fakeMeeting.id,
+            };
+            const payload = {
+              mediaType: 'video' as const,
+            };
+            const submitToCallDiagnosticsStub = sinon.stub(cd, 'submitToCallDiagnostics');
+
+            const baselineCallCount = webex.logger.log.callCount;
+            // Send first event
+            cd.submitClientEvent({
+              name,
+              payload,
+              options,
+            });
+
+            assert.calledOnce(submitToCallDiagnosticsStub);
+            submitToCallDiagnosticsStub.resetHistory();
+
+            // Send second event of same type
+            cd.submitClientEvent({
+              name,
+              payload,
+              options,
+            });
+
+            assert.notCalled(submitToCallDiagnosticsStub);
+            assert.calledWith(
+              webex.logger.log,
+              'call-diagnostic-events -> ',
+              sinon.match(createEventLimitRegex(name, 'mediaType video'))
+            );
+            webex.logger.log.resetHistory();
+
+            // Send third event of same type
+            cd.submitClientEvent({
+              name,
+              payload,
+              options,
+            });
+
+            assert.notCalled(submitToCallDiagnosticsStub);
+            assert.neverCalledWithMatch(webex.logger.log,
+              'call-diagnostic-events -> ',
+              sinon.match(createEventLimitRegex(name, 'mediaType video'))
+            );
+
+            // Send fourth event with a different mediaType
+            cd.submitClientEvent({
+              name,
+              payload: {mediaType: 'audio'},
+              options,
+            });
+
+            assert.calledOnce(submitToCallDiagnosticsStub);
+          });
+
+          it(`should handle share media type with shareInstanceId correctly for ${name}`, () => {
+            const options = {
+              meetingId: fakeMeeting.id,
+            };
+            const payload = {
+              mediaType: 'share' as const,
+              shareInstanceId: 'instance-1',
+            };
+            const submitToCallDiagnosticsStub = sinon.stub(cd, 'submitToCallDiagnostics');
+
+            const baselineCallCount = webex.logger.log.callCount;
+            // Send first event
+            cd.submitClientEvent({
+              name,
+              payload,
+              options,
+            });
+
+            // Send second event with same shareInstanceId
+            cd.submitClientEvent({
+              name,
+              payload,
+              options,
+            });
+
+            // Send event with different shareInstanceId
+            cd.submitClientEvent({
+              name,
+              payload: { ...payload, shareInstanceId: 'instance-2' },
+              options,
+            });
+
+            assert.calledTwice(submitToCallDiagnosticsStub);
+          });
+        });
+
+        ([
+          ['client.roap-message.received'],
+          ['client.roap-message.sent']
+        ] as const).forEach(([name]) => {
+          it(`should not send third event of same type and not log warning again for ${name}`, () => {
+            const options = {
+              meetingId: fakeMeeting.id,
+            };
+            const payload = {
+              roap: {
+                messageType: 'OFFER' as const,
+              },
+            };
+            const submitToCallDiagnosticsStub = sinon.stub(cd, 'submitToCallDiagnostics');
+
+            // Clear any existing call history to get accurate counts
+            webex.logger.log.resetHistory();
+
+            // Send first event
+            cd.submitClientEvent({
+              name,
+              payload,
+              options,
+            });
+
+            assert.calledOnce(submitToCallDiagnosticsStub);
+            submitToCallDiagnosticsStub.resetHistory();
+
+            // Send second event (should trigger warning)
+            cd.submitClientEvent({
+              name,
+              payload,
+              options,
+            });
+
+            assert.notCalled(submitToCallDiagnosticsStub);
+            assert.calledWith(
+              webex.logger.log,
+              'call-diagnostic-events -> ',
+              sinon.match(createEventLimitRegex(name, 'ROAP type OFFER'))
+            );
+            webex.logger.log.resetHistory();
+            
+            cd.submitClientEvent({
+              name,
+              payload,
+              options,
+            });
+
+            assert.notCalled(submitToCallDiagnosticsStub);
+            assert.neverCalledWithMatch(
+              webex.logger.log,
+              'call-diagnostic-events -> ',
+              sinon.match(createEventLimitRegex(name, 'ROAP type OFFER'))
+            );
+          });
+
+          it(`should handle roap.type instead of roap.messageType for ${name}`, () => {
+            const options = {
+              meetingId: fakeMeeting.id,
+            };
+            const payload = {
+              roap: {
+                type: 'ANSWER' as const,
+              },
+            };
+            const submitToCallDiagnosticsStub = sinon.stub(cd, 'submitToCallDiagnostics');
+
+            cd.submitClientEvent({
+              name,
+              payload,
+              options,
+            });
+
+            cd.submitClientEvent({
+              name,
+              payload,
+              options,
+            });
+
+            assert.calledOnce(submitToCallDiagnosticsStub);
+          });
+        });
+      });
     });
 
     describe('#submitToCallDiagnostics', () => {
@@ -4022,5 +4244,186 @@ describe('internal-plugin-metrics', () => {
         assert.notCalled(submitFeatureEventSpy);
       });
     });
+
+    describe('#clearEventLimitsForCorrelationId', () => {
+      beforeEach(() => {
+        cd.clearEventLimits();
+      });
+
+      it('should clear event limits for specific correlationId only', () => {
+        // Use the actual correlationIds from our fakeMeeting fixtures
+        const correlationId1 = fakeMeeting.correlationId;   // e.g. 'correlationId1'
+        const correlationId2 = fakeMeeting2.correlationId;  // e.g. 'correlationId2'
+        const options1 = { meetingId: fakeMeeting.id };
+        const options2 = { meetingId: fakeMeeting2.id };
+        const payload = { mediaType: 'video' as const };
+
+        // Set up events for both correlations to trigger limits
+        cd.submitClientEvent({ name: 'client.media.render.start', payload, options: options1 });
+        cd.submitClientEvent({ name: 'client.media.render.start', payload, options: options2 });
+        cd.submitClientEvent({ name: 'client.media.render.start', payload, options: options1 });
+        cd.submitClientEvent({ name: 'client.media.render.start', payload, options: options2 });
+        assert.isTrue(cd.eventLimitTracker.size > 0);
+        assert.isTrue(cd.eventLimitWarningsLogged.size > 0);
+
+        // Clear limits for only correlationId1 (present)
+        cd.clearEventLimitsForCorrelationId(correlationId1);
+
+        const remainingTrackerKeys = Array.from(cd.eventLimitTracker.keys());
+        const remainingWarningKeys = Array.from(cd.eventLimitWarningsLogged.keys());
+
+        // Should have no keys with correlationId1
+        assert.isFalse(remainingTrackerKeys.some(key => key.split(':')[1] === correlationId1));
+        assert.isFalse(remainingWarningKeys.some(key => key.split(':')[1] === correlationId1));
+
+        // Should still have keys with correlationId2
+        assert.isTrue(remainingTrackerKeys.some(key => key.split(':')[1] === correlationId2));
+        assert.isTrue(remainingWarningKeys.some(key => key.split(':')[1] === correlationId2));
+      });
+
+      it('should handle empty correlationId gracefully', () => {
+        const options = { meetingId: fakeMeeting.id };
+        const payload = { mediaType: 'video' as const };
+
+        // Set up some tracking data
+        cd.submitClientEvent({
+          name: 'client.media.render.start',
+          payload,
+          options,
+        });
+
+        cd.submitClientEvent({
+          name: 'client.media.render.start',
+          payload,
+          options,
+        });
+
+        const initialTrackerSize = cd.eventLimitTracker.size;
+        const initialWarningsSize = cd.eventLimitWarningsLogged.size;
+
+        // Should not clear anything for empty correlationId
+        cd.clearEventLimitsForCorrelationId('');
+        cd.clearEventLimitsForCorrelationId(null as any);
+        cd.clearEventLimitsForCorrelationId(undefined as any);
+
+        assert.equal(cd.eventLimitTracker.size, initialTrackerSize);
+        assert.equal(cd.eventLimitWarningsLogged.size, initialWarningsSize);
+      });
+
+      it('should handle non-existent correlationId gracefully', () => {
+        const options = { meetingId: fakeMeeting.id };
+        const payload = { mediaType: 'video' as const };
+
+        // Set up some tracking data
+        cd.submitClientEvent({
+          name: 'client.media.render.start',
+          payload,
+          options,
+        });
+
+        const initialTrackerSize = cd.eventLimitTracker.size;
+        const initialWarningsSize = cd.eventLimitWarningsLogged.size;
+
+        // Should not clear anything for non-existent correlationId
+        cd.clearEventLimitsForCorrelationId('nonExistentCorrelationId');
+
+        assert.equal(cd.eventLimitTracker.size, initialTrackerSize);
+        assert.equal(cd.eventLimitWarningsLogged.size, initialWarningsSize);
+      });
+
+      it('should clear multiple event types for the same correlationId', () => {
+        const correlationId = fakeMeeting.correlationId;
+        const options = { meetingId: fakeMeeting.id };
+        const videoPayload = { mediaType: 'video' as const };
+        const audioPayload = { mediaType: 'audio' as const };
+        const roapPayload = { roap: { messageType: 'OFFER' as const } };
+
+        // Set up multiple event types for the same correlation
+        cd.submitClientEvent({
+          name: 'client.media.render.start',
+          payload: videoPayload,
+          options,
+        });
+
+        cd.submitClientEvent({
+          name: 'client.media.render.start',
+          payload: audioPayload,
+          options,
+        });
+
+        cd.submitClientEvent({
+          name: 'client.roap-message.sent',
+          payload: roapPayload,
+          options,
+        });
+
+        // Trigger limits
+        cd.submitClientEvent({
+          name: 'client.media.render.start',
+          payload: videoPayload,
+          options,
+        });
+
+        cd.submitClientEvent({
+          name: 'client.media.render.start',
+          payload: audioPayload,
+          options,
+        });
+
+        cd.submitClientEvent({
+          name: 'client.roap-message.sent',
+          payload: roapPayload,
+          options,
+        });
+
+        assert.isTrue(cd.eventLimitTracker.size > 0);
+        assert.isTrue(cd.eventLimitWarningsLogged.size > 0);
+
+        // Clear all limits for this correlationId
+        cd.clearEventLimitsForCorrelationId(correlationId);
+
+        // Should clear all tracking data for this correlationId
+        assert.equal(cd.eventLimitTracker.size, 0);
+        assert.equal(cd.eventLimitWarningsLogged.size, 0);
+      });
+
+      it('should allow events to be sent again after clearing limits for correlationId', () => {
+        const correlationId = fakeMeeting.correlationId;
+        const options = { meetingId: fakeMeeting.id };
+        const payload = { mediaType: 'video' as const };
+        const submitToCallDiagnosticsStub = sinon.stub(cd, 'submitToCallDiagnostics');
+
+        // Send first event (should succeed)
+        cd.submitClientEvent({
+          name: 'client.media.render.start',
+          payload,
+          options,
+        });
+
+        assert.calledOnce(submitToCallDiagnosticsStub);
+        submitToCallDiagnosticsStub.resetHistory();
+
+        // Send second event (should be blocked)
+        cd.submitClientEvent({
+          name: 'client.media.render.start',
+          payload,
+          options,
+        });
+
+        assert.notCalled(submitToCallDiagnosticsStub);
+
+        // Clear limits for this correlationId
+        cd.clearEventLimitsForCorrelationId(correlationId);
+
+        // Send event again (should succeed after clearing)
+        cd.submitClientEvent({
+          name: 'client.media.render.start',
+          payload,
+          options,
+        });
+
+        assert.calledOnce(submitToCallDiagnosticsStub);
+      });
+    });
   });
 });