@webex/internal-plugin-metrics 3.8.1-web-workers-keepalive.1 → 3.9.0-next.1

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});
@@ -918,6 +994,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);
+      });
+    });
   });
 });

package/test/unit/spec/prelogin-metrics-batcher.ts

@@ -17,7 +17,7 @@ describe('internal-plugin-metrics', () => {
     let webex;
     let clock;
     let now;
-
+    const deviceManagerStub = {getPairedDevice: sinon.stub()};
     const preLoginId = 'my_prelogin_id';
 
     beforeEach(() => {
@@ -30,6 +30,7 @@ describe('internal-plugin-metrics', () => {
           newMetrics: NewMetrics,
         },
       });
+      webex.devicemanager = deviceManagerStub;
 
       webex.request = (options) =>
         Promise.resolve({body: {items: []}, waitForServiceTimeout: 15, options});
@@ -217,9 +218,7 @@ describe('internal-plugin-metrics', () => {
         });
 
         assert.deepEqual(calls.args[0].type, ['diagnostic-event']);
-
         const prepareDiagnosticMetricItemCalls = prepareDiagnosticMetricItemSpy.getCalls();
-
         // second argument (item) also gets assigned a delay property but the key is a Symbol and haven't been able to test that..
         assert.deepEqual(prepareDiagnosticMetricItemCalls[0].args[0], webex);
         assert.deepEqual(prepareDiagnosticMetricItemCalls[0].args[1].eventPayload, {
@@ -232,6 +231,75 @@ describe('internal-plugin-metrics', () => {
         });
         assert.deepEqual(prepareDiagnosticMetricItemCalls[0].args[1].type, ['diagnostic-event']);
       });
+      it('adds the paired device to the metric payload if paired', async () => {
+        webex.internal.newMetrics.callDiagnosticMetrics.preLoginMetricsBatcher.prepareRequest = (
+          q
+        ) => Promise.resolve(q);
+        webex.devicemanager.getPairedDevice = sinon.stub().returns({
+          deviceInfo: {
+            id: 'my_device_id',
+          },
+          url: 'my_url',
+          mode: 'personal',
+          devices: [{productName: 'my_product_name'}],
+        });
+        webex.devicemanager.getPairedMethod = sinon.stub().returns("Manual");
+
+        const prepareItemSpy = sinon.spy(
+          webex.internal.newMetrics.callDiagnosticMetrics.preLoginMetricsBatcher,
+          'prepareItem'
+        );
+        const prepareDiagnosticMetricItemSpy = sinon.spy(
+          CallDiagnosticUtils,
+          'prepareDiagnosticMetricItem'
+        );
+
+        const promise =
+          webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnosticsPreLogin(
+            {
+              event: {name: 'client.interstitial-window.launched'},
+            },
+            preLoginId
+          );
+
+        await flushPromises();
+
+        clock.tick(config.metrics.batcherWait);
+
+        await promise;
+
+        const calls = prepareItemSpy.getCalls()[0];
+
+        assert.deepEqual(calls.args[0].eventPayload, {
+            event: {
+              joinTimes: {
+                meetingInfoReqResp: undefined,
+                clickToInterstitial: undefined,
+                clickToInterstitialWithUserDelay: undefined,
+                refreshCaptchaServiceReqResp: undefined,
+                downloadIntelligenceModelsReqResp: undefined,
+              },
+              name: 'client.interstitial-window.launched',
+              pairedDevice: {
+                deviceId: 'my_device_id',
+                deviceURL: 'my_url',
+                devicePairingType: 'Manual',
+                productName: 'my_product_name',
+                isPersonalDevice: true,
+              },
+              pairingState: 'paired',
+            },
+            origin: {
+              buildType: 'test',
+              networkType: 'unknown',
+              upgradeChannel: 'test',
+            },
+        });
+
+        assert.deepEqual(calls.args[0].type, ['diagnostic-event']);
+        assert.calledOnce(webex.devicemanager.getPairedDevice);
+       
+      });
     });
 
     describe('savePreLoginId', () => {