@webex/internal-plugin-metrics 3.12.0-next.6 → 3.12.0-next.60

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

@@ -9,6 +9,7 @@ import {
   CallDiagnosticMetrics,
   getOSNameInternal,
   CallDiagnosticUtils,
+  AutomatedUserUtils,
   config,
 } from '@webex/internal-plugin-metrics';
 import uuid from 'uuid';
@@ -34,6 +35,7 @@ describe('internal-plugin-metrics', () => {
     var now = new Date();
 
     let cd: CallDiagnosticMetrics;
+    let isAutomatedUserStub: sinon.SinonStub;
 
     const fakeMeeting = {
       id: '1',
@@ -79,12 +81,20 @@ describe('internal-plugin-metrics', () => {
       emailInput: 'test@test.com',
     };
 
+    const fakeMeeting6 = {
+      ...fakeMeeting,
+      id: '6',
+      correlationId: 'correlationId6',
+      callStateForMetrics: {meetingJoinPhase: 'in-meeting'},
+    };
+
     const fakeMeetings = {
       1: fakeMeeting,
       2: fakeMeeting2,
       3: fakeMeeting3,
       4: fakeMeeting4,
       5: fakeMeeting5,
+      6: fakeMeeting6,
     };
 
     let webex;
@@ -155,6 +165,7 @@ describe('internal-plugin-metrics', () => {
       sinon.useFakeTimers(now.getTime());
       cd = new CallDiagnosticMetrics({}, {parent: webex});
       sinon.stub(uuid, 'v4').returns('my-fake-id');
+      isAutomatedUserStub = sinon.stub(AutomatedUserUtils, 'isAutomatedUser').returns(false);
       cd.setDeviceInfo(webex.internal.device);
     });
 
@@ -361,6 +372,23 @@ describe('internal-plugin-metrics', () => {
         });
       });
 
+      it('should build origin correctly when the meetings plugin is not available (before webex is ready)', () => {
+        // meetings plugin, geoHintInfo and meetingCollection are all absent before webex.ready
+        webex.meetings = undefined;
+
+        //@ts-ignore
+        const res = cd.getOrigin(
+          {subClientType: 'WEB_APP', clientType: 'TEAMS_CLIENT'},
+          fakeMeeting.id
+        );
+
+        assert.equal(res.clientInfo.clientType, 'TEAMS_CLIENT');
+        assert.equal(res.clientInfo.subClientType, 'WEB_APP');
+        assert.isUndefined(res.clientInfo.publicNetworkPrefix);
+        assert.isUndefined(res.clientInfo.localNetworkPrefix);
+        assert.equal(res.name, 'endpoint');
+      });
+
       it('builds origin correctly, when overriding clientVersion', () => {
         webex.meetings.config.metrics.clientVersion = '43.9.0.1234';
 
@@ -391,6 +419,64 @@ describe('internal-plugin-metrics', () => {
         });
       });
 
+      it('builds origin correctly with browser details provided by the host client', () => {
+        // host resolves wrapper browsers (WebOS, Electron) to the engine that determines capability
+        webex.meetings.config.metrics.browser = 'WebOS Browser';
+        webex.meetings.config.metrics.browserVersion = '108.0.0.0';
+
+        //@ts-ignore
+        const res = cd.getOrigin(
+          {subClientType: 'WEB_APP', clientType: 'TEAMS_CLIENT'},
+          fakeMeeting.id
+        );
+
+        assert.equal(res.clientInfo.browser, 'WebOS Browser');
+        assert.equal(res.clientInfo.browserVersion, '108.0.0.0');
+      });
+
+      it('falls back to SDK browser detection when the host provides nothing', () => {
+        //@ts-ignore
+        const res = cd.getOrigin(
+          {subClientType: 'WEB_APP', clientType: 'TEAMS_CLIENT'},
+          fakeMeeting.id
+        );
+
+        assert.equal(res.clientInfo.browser, getBrowserName());
+        assert.equal(res.clientInfo.browserVersion, getBrowserVersion());
+      });
+
+      it('builds origin correctly with the browser support flags from config', () => {
+        // `false` is the meaningful "unsupported family" signal, so it must survive a truthy check
+        webex.meetings.config.metrics.isSupportedBrowserFamily = false;
+        webex.meetings.config.metrics.isOutdatedBrowserVersion = true;
+
+        //@ts-ignore
+        const res = cd.getOrigin(
+          {subClientType: 'WEB_APP', clientType: 'TEAMS_CLIENT'},
+          fakeMeeting.id
+        );
+
+        assert.deepEqual(res, {
+          clientInfo: {
+            browser: getBrowserName(),
+            browserVersion: getBrowserVersion(),
+            clientType: 'TEAMS_CLIENT',
+            clientVersion: 'webex-js-sdk/webex-version',
+            publicNetworkPrefix: '1.3.4.0',
+            localNetworkPrefix: '192.168.1.80',
+            os: getOSNameInternal(),
+            osVersion: getOSVersion() || 'unknown',
+            subClientType: 'WEB_APP',
+            isSupportedBrowserFamily: false,
+            isOutdatedBrowserVersion: true,
+          },
+          environment: 'meeting_evn',
+          name: 'endpoint',
+          networkType: 'unknown',
+          userAgent,
+        });
+      });
+
       it('should build origin correctly with no meeting or stats analyzer', () => {
         //@ts-ignore
         const res = cd.getOrigin();
@@ -637,6 +723,63 @@ describe('internal-plugin-metrics', () => {
         });
       });
 
+      it('should build identifiers correctly with a meeting that has meetingInfo with locusClusterUrl', () => {
+        const res = cd.getIdentifiers({
+          mediaConnections: [
+            {mediaAgentAlias: 'mediaAgentAlias', mediaAgentGroupId: 'mediaAgentGroupId'},
+          ],
+          meeting: {
+            ...fakeMeeting,
+            meetingInfo: {
+              ...fakeMeeting.meetingInfo,
+              locusClusterUrl: 'locus-k.wbx2.com',
+            },
+          },
+        });
+
+        assert.deepEqual(res, {
+          correlationId: 'correlationId',
+          deviceId: 'deviceUrl',
+          locusCluster: 'locus-k.wbx2.com',
+          locusId: 'url',
+          locusSessionId: 'locusSessionId',
+          locusStartTime: 'lastActive',
+          locusUrl: 'locus/url',
+          mediaAgentAlias: 'mediaAgentAlias',
+          mediaAgentGroupId: 'mediaAgentGroupId',
+          orgId: 'orgId',
+          userId: 'userId',
+        });
+      });
+
+      it('should build identifiers correctly given locusCluster', () => {
+        const res = cd.getIdentifiers({
+          correlationId: 'correlationId',
+          locusCluster: 'locus-k.wbx2.com',
+        });
+
+        assert.deepEqual(res, {
+          correlationId: 'correlationId',
+          deviceId: 'deviceUrl',
+          locusCluster: 'locus-k.wbx2.com',
+          locusUrl: 'locus-url',
+          orgId: 'orgId',
+          userId: 'userId',
+        });
+      });
+
+      it('should prefer meetingInfo locusClusterUrl over the locusCluster option', () => {
+        const res = cd.getIdentifiers({
+          meeting: {
+            ...fakeMeeting,
+            meetingInfo: {...fakeMeeting.meetingInfo, locusClusterUrl: 'locus-k.wbx2.com'},
+          },
+          locusCluster: 'locus-a.wbx2.com',
+        });
+
+        assert.equal(res.locusCluster, 'locus-k.wbx2.com');
+      });
+
       it('should build identifiers correctly with a meeting that has sessionCorrelationId', () => {
         const res = cd.getIdentifiers({
           mediaConnections: [
@@ -763,6 +906,60 @@ describe('internal-plugin-metrics', () => {
           userId: 'preLoginId',
         });
       });
+
+      it('should use the userId from credentials when no device userId is available', () => {
+        cd.device.userId = undefined;
+        webex.credentials.getUserId = sinon.stub().returns('credentials-user-id');
+
+        const res = cd.getIdentifiers({
+          correlationId: 'correlationId',
+        });
+
+        assert.deepEqual(res, {
+          correlationId: 'correlationId',
+          locusUrl: 'locus-url',
+          deviceId: 'deviceUrl',
+          orgId: 'orgId',
+          userId: 'credentials-user-id',
+        });
+      });
+
+      it('should prefer the device userId over the credentials userId', () => {
+        webex.credentials.getUserId = sinon.stub().returns('credentials-user-id');
+
+        const res = cd.getIdentifiers({
+          correlationId: 'correlationId',
+        });
+
+        assert.equal(res.userId, 'userId');
+        assert.notCalled(webex.credentials.getUserId);
+      });
+
+      it('should fall back to preLoginId when neither the device nor credentials provide a userId', () => {
+        cd.device.userId = undefined;
+        webex.credentials.getUserId = sinon.stub().throws(new Error('no user token available'));
+
+        const res = cd.getIdentifiers({
+          correlationId: 'correlationId',
+          preLoginId: 'preLoginId',
+        });
+
+        assert.equal(res.userId, 'preLoginId');
+      });
+    });
+
+    describe('#getUserIdFromCredentials', () => {
+      it('should return the userId from credentials', () => {
+        webex.credentials.getUserId = sinon.stub().returns('credentials-user-id');
+
+        assert.equal(cd.getUserIdFromCredentials(), 'credentials-user-id');
+      });
+
+      it('should return undefined when credentials cannot provide a userId', () => {
+        webex.credentials.getUserId = sinon.stub().throws(new Error('no user token available'));
+
+        assert.isUndefined(cd.getUserIdFromCredentials());
+      });
     });
 
     it('should prepare diagnostic event successfully', () => {
@@ -857,6 +1054,103 @@ describe('internal-plugin-metrics', () => {
       });
     });
 
+    describe('#prepareDiagnosticEvent isAutomatedUser field', () => {
+      it('should set isAutomatedUser to false when window is not defined', () => {
+        const options = {meetingId: fakeMeeting.id};
+        sinon.stub(cd, 'getOrigin').returns({origin: 'fake-origin'});
+
+        const res = cd.prepareDiagnosticEvent(
+          {
+            canProceed: true,
+            identifiers: {correlationId: 'test-id'},
+            name: 'client.alert.displayed',
+            isAutomatedUser: false,
+            userActivation: undefined,
+          },
+          options
+        );
+
+        // In the test environment, isAutomatedUser should be false since we're not in a webdriver environment
+        assert.isFalse(
+          res.event.isAutomatedUser,
+          'isAutomatedUser should be false in non-webdriver test environment'
+        );
+      });
+
+      it('should include isAutomatedUser field in the returned event', () => {
+        const options = {meetingId: fakeMeeting.id};
+        sinon.stub(cd, 'getOrigin').returns({origin: 'fake-origin'});
+
+        const res = cd.prepareDiagnosticEvent(
+          {
+            canProceed: true,
+            identifiers: {correlationId: 'test-id'},
+            name: 'client.alert.displayed',
+            isAutomatedUser: false,
+            userActivation: undefined,
+          },
+          options
+        );
+
+        // Verify the isAutomatedUser field is present in the event
+        assert.isDefined(res.event.isAutomatedUser, 'isAutomatedUser field should be defined');
+        assert.isBoolean(res.event.isAutomatedUser, 'isAutomatedUser should be a boolean');
+      });
+
+      it('should set isAutomatedUser to true when the user is automated', () => {
+        isAutomatedUserStub.returns(true);
+        const prepareDiagnosticEventSpy = sinon.spy(cd, 'prepareDiagnosticEvent');
+        sinon.stub(cd, 'getOrigin').returns({origin: 'fake-origin'});
+        cd.setMercuryConnectedStatus(true);
+
+        cd.submitClientEvent({
+          name: 'client.alert.displayed',
+          options: {correlationId: 'correlationId'},
+        });
+
+        assert.isTrue(
+          prepareDiagnosticEventSpy.firstCall.args[0].isAutomatedUser,
+          'isAutomatedUser should be true for an automated user'
+        );
+      });
+    });
+
+    describe('#getUserActivation', () => {
+      let originalDescriptor;
+
+      beforeEach(() => {
+        originalDescriptor = Object.getOwnPropertyDescriptor(global, 'navigator');
+      });
+
+      afterEach(() => {
+        if (originalDescriptor) {
+          Object.defineProperty(global, 'navigator', originalDescriptor);
+        } else {
+          delete (global as any).navigator;
+        }
+      });
+
+      it('should return the userActivation state when navigator.userActivation is available', () => {
+        Object.defineProperty(global, 'navigator', {
+          value: {userActivation: {hasBeenActive: true, isActive: false}},
+          configurable: true,
+          writable: true,
+        });
+
+        assert.deepEqual(cd.getUserActivation(), {hasBeenActive: true, isActive: false});
+      });
+
+      it('should return undefined when navigator.userActivation is not available', () => {
+        Object.defineProperty(global, 'navigator', {
+          value: {},
+          configurable: true,
+          writable: true,
+        });
+
+        assert.isUndefined(cd.getUserActivation());
+      });
+    });
+
     describe('#submitClientEvent', () => {
       it('should submit client event successfully with meetingId', () => {
         const prepareDiagnosticEventSpy = sinon.spy(cd, 'prepareDiagnosticEvent');
@@ -884,6 +1178,7 @@ describe('internal-plugin-metrics', () => {
           webexConferenceIdStr: undefined,
           sessionCorrelationId: undefined,
           globalMeetingId: undefined,
+          locusCluster: undefined,
         });
         assert.notCalled(generateClientEventErrorPayloadSpy);
         assert.calledWith(
@@ -907,11 +1202,15 @@ describe('internal-plugin-metrics', () => {
               userId: 'userId',
             },
             loginType: 'login-ci',
+            telemetryOptOut: undefined,
             name: 'client.alert.displayed',
             userType: 'host',
             isConvergedArchitectureEnabled: undefined,
             webexSubServiceType: undefined,
             webClientPreload: undefined,
+            isVipMeeting: false,
+            isAutomatedUser: false,
+            userActivation: undefined,
           },
           options
         );
@@ -935,11 +1234,15 @@ describe('internal-plugin-metrics', () => {
               userId: 'userId',
             },
             loginType: 'login-ci',
+            telemetryOptOut: undefined,
             name: 'client.alert.displayed',
             userType: 'host',
             isConvergedArchitectureEnabled: undefined,
             webexSubServiceType: undefined,
             webClientPreload: undefined,
+            isVipMeeting: false,
+            isAutomatedUser: false,
+            userActivation: undefined,
           },
           eventId: 'my-fake-id',
           origin: {
@@ -974,11 +1277,15 @@ describe('internal-plugin-metrics', () => {
                 userId: 'userId',
               },
               loginType: 'login-ci',
+              telemetryOptOut: undefined,
               name: 'client.alert.displayed',
               userType: 'host',
               isConvergedArchitectureEnabled: undefined,
               webexSubServiceType: undefined,
               webClientPreload: undefined,
+              isVipMeeting: false,
+              isAutomatedUser: false,
+              userActivation: undefined,
             },
             eventId: 'my-fake-id',
             origin: {
@@ -1026,6 +1333,7 @@ describe('internal-plugin-metrics', () => {
           webexConferenceIdStr: undefined,
           sessionCorrelationId: undefined,
           globalMeetingId: undefined,
+          locusCluster: undefined,
         });
         assert.notCalled(generateClientEventErrorPayloadSpy);
         assert.calledWith(
@@ -1049,11 +1357,15 @@ describe('internal-plugin-metrics', () => {
               userId: 'userId',
             },
             loginType: 'login-ci',
+            telemetryOptOut: undefined,
             name: 'client.alert.displayed',
             userType: 'host',
             isConvergedArchitectureEnabled: undefined,
             webexSubServiceType: undefined,
             webClientPreload: undefined,
+            isVipMeeting: false,
+            isAutomatedUser: false,
+            userActivation: undefined,
           },
           options
         );
@@ -1077,11 +1389,15 @@ describe('internal-plugin-metrics', () => {
               userId: 'userId',
             },
             loginType: 'login-ci',
+            telemetryOptOut: undefined,
             name: 'client.alert.displayed',
             userType: 'host',
             isConvergedArchitectureEnabled: undefined,
             webexSubServiceType: undefined,
             webClientPreload: undefined,
+            isVipMeeting: false,
+            isAutomatedUser: false,
+            userActivation: undefined,
           },
           eventId: 'my-fake-id',
           origin: {
@@ -1116,11 +1432,15 @@ describe('internal-plugin-metrics', () => {
                 userId: 'userId',
               },
               loginType: 'login-ci',
+              telemetryOptOut: undefined,
               name: 'client.alert.displayed',
               userType: 'host',
               isConvergedArchitectureEnabled: undefined,
               webexSubServiceType: undefined,
               webClientPreload: undefined,
+              isVipMeeting: false,
+              isAutomatedUser: false,
+              userActivation: undefined,
             },
             eventId: 'my-fake-id',
             origin: {
@@ -1168,6 +1488,7 @@ describe('internal-plugin-metrics', () => {
           webexConferenceIdStr: undefined,
           globalMeetingId: undefined,
           sessionCorrelationId: undefined,
+          locusCluster: undefined,
         });
         assert.notCalled(generateClientEventErrorPayloadSpy);
         assert.calledWith(
@@ -1192,11 +1513,15 @@ describe('internal-plugin-metrics', () => {
               userId: 'userId',
             },
             loginType: 'login-ci',
+            telemetryOptOut: undefined,
             name: 'client.alert.displayed',
             userType: 'host',
             isConvergedArchitectureEnabled: undefined,
             webexSubServiceType: undefined,
             webClientPreload: undefined,
+            isVipMeeting: false,
+            isAutomatedUser: false,
+            userActivation: undefined,
           },
           options
         );
@@ -1221,11 +1546,15 @@ describe('internal-plugin-metrics', () => {
               userId: 'userId',
             },
             loginType: 'login-ci',
+            telemetryOptOut: undefined,
             name: 'client.alert.displayed',
             userType: 'host',
             isConvergedArchitectureEnabled: undefined,
             webexSubServiceType: undefined,
             webClientPreload: undefined,
+            isVipMeeting: false,
+            isAutomatedUser: false,
+            userActivation: undefined,
           },
           eventId: 'my-fake-id',
           origin: {
@@ -1261,11 +1590,15 @@ describe('internal-plugin-metrics', () => {
                 userId: 'userId',
               },
               loginType: 'login-ci',
+              telemetryOptOut: undefined,
               name: 'client.alert.displayed',
               userType: 'host',
               isConvergedArchitectureEnabled: undefined,
               webexSubServiceType: undefined,
               webClientPreload: undefined,
+              isVipMeeting: false,
+              isAutomatedUser: false,
+              userActivation: undefined,
             },
             eventId: 'my-fake-id',
             origin: {
@@ -1312,6 +1645,7 @@ describe('internal-plugin-metrics', () => {
           webexConferenceIdStr: undefined,
           globalMeetingId: undefined,
           sessionCorrelationId: undefined,
+          locusCluster: undefined,
         });
         assert.notCalled(generateClientEventErrorPayloadSpy);
         assert.calledWith(
@@ -1336,11 +1670,15 @@ describe('internal-plugin-metrics', () => {
               userId: 'userId',
             },
             loginType: 'login-ci',
+            telemetryOptOut: undefined,
             webClientPreload: undefined,
             name: 'client.alert.displayed',
             userType: 'host',
             isConvergedArchitectureEnabled: undefined,
             webexSubServiceType: undefined,
+            isVipMeeting: false,
+            isAutomatedUser: false,
+            userActivation: undefined,
           },
           options
         );
@@ -1365,11 +1703,15 @@ describe('internal-plugin-metrics', () => {
               userId: 'userId',
             },
             loginType: 'login-ci',
+            telemetryOptOut: undefined,
             webClientPreload: undefined,
             name: 'client.alert.displayed',
             userType: 'host',
             isConvergedArchitectureEnabled: undefined,
             webexSubServiceType: undefined,
+            isVipMeeting: false,
+            isAutomatedUser: false,
+            userActivation: undefined,
           },
           eventId: 'my-fake-id',
           origin: {
@@ -1405,11 +1747,15 @@ describe('internal-plugin-metrics', () => {
                 userId: 'userId',
               },
               loginType: 'login-ci',
+              telemetryOptOut: undefined,
               webClientPreload: undefined,
               name: 'client.alert.displayed',
               userType: 'host',
               isConvergedArchitectureEnabled: undefined,
               webexSubServiceType: undefined,
+              isVipMeeting: false,
+              isAutomatedUser: false,
+              userActivation: undefined,
             },
             eventId: 'my-fake-id',
             origin: {
@@ -1456,6 +1802,7 @@ describe('internal-plugin-metrics', () => {
           webexConferenceIdStr: undefined,
           globalMeetingId: undefined,
           sessionCorrelationId: undefined,
+          locusCluster: undefined,
         });
         assert.notCalled(generateClientEventErrorPayloadSpy);
         assert.calledWith(
@@ -1480,6 +1827,7 @@ describe('internal-plugin-metrics', () => {
               userId: 'userId',
             },
             loginType: 'login-ci',
+            telemetryOptOut: undefined,
             name: 'client.alert.displayed',
             userType: 'host',
             userNameInput: 'test',
@@ -1487,6 +1835,9 @@ describe('internal-plugin-metrics', () => {
             isConvergedArchitectureEnabled: undefined,
             webexSubServiceType: undefined,
             webClientPreload: undefined,
+            isVipMeeting: false,
+            isAutomatedUser: false,
+            userActivation: undefined,
           },
           options
         );
@@ -1511,6 +1862,7 @@ describe('internal-plugin-metrics', () => {
               userId: 'userId',
             },
             loginType: 'login-ci',
+            telemetryOptOut: undefined,
             name: 'client.alert.displayed',
             userType: 'host',
             userNameInput: 'test',
@@ -1518,6 +1870,9 @@ describe('internal-plugin-metrics', () => {
             isConvergedArchitectureEnabled: undefined,
             webexSubServiceType: undefined,
             webClientPreload: undefined,
+            isVipMeeting: false,
+            isAutomatedUser: false,
+            userActivation: undefined,
           },
           eventId: 'my-fake-id',
           origin: {
@@ -1553,6 +1908,7 @@ describe('internal-plugin-metrics', () => {
                 userId: 'userId',
               },
               loginType: 'login-ci',
+              telemetryOptOut: undefined,
               name: 'client.alert.displayed',
               userType: 'host',
               userNameInput: 'test',
@@ -1560,6 +1916,9 @@ describe('internal-plugin-metrics', () => {
               isConvergedArchitectureEnabled: undefined,
               webexSubServiceType: undefined,
               webClientPreload: undefined,
+              isVipMeeting: false,
+              isAutomatedUser: false,
+              userActivation: undefined,
             },
             eventId: 'my-fake-id',
             origin: {
@@ -1662,6 +2021,7 @@ describe('internal-plugin-metrics', () => {
           globalMeetingId: 'globalMeetingId1',
           sessionCorrelationId: 'sessionCorrelationId1',
           preLoginId: undefined,
+          locusCluster: undefined,
         });
 
         assert.notCalled(generateClientEventErrorPayloadSpy);
@@ -1684,8 +2044,12 @@ describe('internal-plugin-metrics', () => {
               userId: 'userId',
             },
             loginType: 'login-ci',
+            telemetryOptOut: undefined,
             name: 'client.alert.displayed',
             webClientPreload: undefined,
+            isAutomatedUser: false,
+            userActivation: undefined,
+            meetingJoinPhase: 'pre-join',
           },
           options
         );
@@ -1707,8 +2071,12 @@ describe('internal-plugin-metrics', () => {
               userId: 'userId',
             },
             loginType: 'login-ci',
+            telemetryOptOut: undefined,
             name: 'client.alert.displayed',
             webClientPreload: undefined,
+            isAutomatedUser: false,
+            userActivation: undefined,
+            meetingJoinPhase: 'pre-join',
           },
           eventId: 'my-fake-id',
           origin: {
@@ -1760,6 +2128,7 @@ describe('internal-plugin-metrics', () => {
           globalMeetingId: 'globalMeetingId1',
           preLoginId: 'myPreLoginId',
           sessionCorrelationId: 'sessionCorrelationId1',
+          locusCluster: undefined,
         });
 
         assert.notCalled(generateClientEventErrorPayloadSpy);
@@ -1782,8 +2151,12 @@ describe('internal-plugin-metrics', () => {
               userId: 'myPreLoginId',
             },
             loginType: 'login-ci',
+            telemetryOptOut: undefined,
             name: 'client.alert.displayed',
             webClientPreload: undefined,
+            isAutomatedUser: false,
+            userActivation: undefined,
+            meetingJoinPhase: 'pre-join',
           },
           options
         );
@@ -1811,13 +2184,47 @@ describe('internal-plugin-metrics', () => {
               },
               eventData: {webClientDomain: 'whatever', isMercuryConnected: true},
               loginType: 'login-ci',
+              telemetryOptOut: undefined,
               webClientPreload: undefined,
+              isAutomatedUser: false,
+              userActivation: undefined,
+              meetingJoinPhase: 'pre-join',
             },
           },
           options.preLoginId
         );
       });
 
+      it('should add locusCluster from options to a pre-meeting client event', () => {
+        const prepareDiagnosticEventSpy = sinon.spy(cd, 'prepareDiagnosticEvent');
+        sinon.stub(cd, 'getOrigin').returns({origin: 'fake-origin'});
+
+        cd.submitClientEvent({
+          name: 'client.meetinginfo.response',
+          options: {correlationId: 'correlationId', locusCluster: 'locus-k.wbx2.com'},
+        });
+
+        assert.equal(
+          prepareDiagnosticEventSpy.firstCall.args[0].identifiers.locusCluster,
+          'locus-k.wbx2.com'
+        );
+      });
+
+      it('should add locusCluster from options to an in-meeting client event when the meeting has none', () => {
+        const prepareDiagnosticEventSpy = sinon.spy(cd, 'prepareDiagnosticEvent');
+        sinon.stub(cd, 'getOrigin').returns({origin: 'fake-origin'});
+
+        cd.submitClientEvent({
+          name: 'client.interstitial-window.launched',
+          options: {meetingId: fakeMeeting.id, locusCluster: 'locus-k.wbx2.com'},
+        });
+
+        assert.equal(
+          prepareDiagnosticEventSpy.firstCall.args[0].identifiers.locusCluster,
+          'locus-k.wbx2.com'
+        );
+      });
+
       it('should submit client event successfully with emailInput and userNameInput as options', () => {
         cd.device.userId = undefined;
 
@@ -1849,6 +2256,7 @@ describe('internal-plugin-metrics', () => {
           globalMeetingId: 'globalMeetingId1',
           preLoginId: 'myPreLoginId',
           sessionCorrelationId: 'sessionCorrelationId1',
+          locusCluster: undefined,
         });
 
         assert.notCalled(generateClientEventErrorPayloadSpy);
@@ -1873,8 +2281,12 @@ describe('internal-plugin-metrics', () => {
             userNameInput: 'current',
             emailInput: 'current',
             loginType: 'login-ci',
+            telemetryOptOut: undefined,
             name: 'client.alert.displayed',
             webClientPreload: undefined,
+            isAutomatedUser: false,
+            userActivation: undefined,
+            meetingJoinPhase: 'pre-join',
           },
           options
         );
@@ -1902,9 +2314,13 @@ describe('internal-plugin-metrics', () => {
               },
               eventData: {webClientDomain: 'whatever', isMercuryConnected: true},
               loginType: 'login-ci',
+              telemetryOptOut: undefined,
               userNameInput: 'current',
               emailInput: 'current',
               webClientPreload: undefined,
+              isAutomatedUser: false,
+              userActivation: undefined,
+              meetingJoinPhase: 'pre-join',
             },
           },
           options.preLoginId
@@ -1944,12 +2360,16 @@ describe('internal-plugin-metrics', () => {
               userId: 'userId',
             },
             loginType: 'fakeLoginType',
+            telemetryOptOut: undefined,
             name: 'client.alert.displayed',
             userType: 'host',
             joinFlowVersion: 'Other',
             isConvergedArchitectureEnabled: undefined,
             webexSubServiceType: undefined,
             webClientPreload: undefined,
+            isVipMeeting: false,
+            isAutomatedUser: false,
+            userActivation: undefined,
           },
           eventId: 'my-fake-id',
           origin: {
@@ -1999,12 +2419,16 @@ describe('internal-plugin-metrics', () => {
               userId: 'userId',
             },
             loginType: 'fakeLoginType',
+            telemetryOptOut: undefined,
             name: 'client.alert.displayed',
             userType: 'host',
             joinFlowVersion: 'Other',
             isConvergedArchitectureEnabled: undefined,
             webexSubServiceType: undefined,
             webClientPreload: undefined,
+            isVipMeeting: false,
+            isAutomatedUser: false,
+            userActivation: undefined,
           },
           eventId: 'my-fake-id',
           origin: {
@@ -2059,8 +2483,12 @@ describe('internal-plugin-metrics', () => {
               userId: 'userId',
             },
             loginType: 'login-ci',
+            telemetryOptOut: undefined,
             name: 'client.alert.displayed',
             webClientPreload: true,
+            isAutomatedUser: false,
+            userActivation: undefined,
+            meetingJoinPhase: 'pre-join',
           },
           options
         );
@@ -2082,8 +2510,12 @@ describe('internal-plugin-metrics', () => {
               userId: 'userId',
             },
             loginType: 'login-ci',
+            telemetryOptOut: undefined,
             name: 'client.alert.displayed',
             webClientPreload: true,
+            isAutomatedUser: false,
+            userActivation: undefined,
+            meetingJoinPhase: 'pre-join',
           },
           eventId: 'my-fake-id',
           origin: {
@@ -2098,20 +2530,25 @@ describe('internal-plugin-metrics', () => {
         });
       });
 
-      it('it should include errors if provided with meetingId', () => {
-        sinon.stub(cd, 'getOrigin').returns({origin: 'fake-origin'});
+      it('should submit client event with isVipMeeting: false when vipMeeting is false', () => {
+        const prepareDiagnosticEventSpy = sinon.spy(cd, 'prepareDiagnosticEvent');
         const submitToCallDiagnosticsSpy = sinon.spy(cd, 'submitToCallDiagnostics');
+        const generateClientEventErrorPayloadSpy = sinon.spy(cd, 'generateClientEventErrorPayload');
+        sinon.stub(cd, 'getOrigin').returns({origin: 'fake-origin'});
+
+        webex.meetings.getBasicMeetingInformation = sinon.stub().returns({
+          ...fakeMeeting,
+          meetingInfo: {
+            vipmeeting: false,
+          },
+        });
 
         const options = {
-          meetingId: fakeMeeting.id,
+          correlationId: 'correlationId',
           webexConferenceIdStr: 'webexConferenceIdStr1',
           globalMeetingId: 'globalMeetingId1',
-          mediaConnections: [{mediaAgentAlias: 'alias', mediaAgentGroupId: '1'}],
-          rawError: {
-            body: {
-              errorCode: 2409005,
-            },
-          },
+          sessionCorrelationId: 'sessionCorrelationId1',
+          meetingId: fakeMeeting.id,
         };
         cd.setMercuryConnectedStatus(true);
         cd.submitClientEvent({
@@ -2119,8 +2556,10 @@ describe('internal-plugin-metrics', () => {
           options,
         });
 
-        assert.calledWith(submitToCallDiagnosticsSpy, {
-          event: {
+        assert.notCalled(generateClientEventErrorPayloadSpy);
+        assert.calledWith(
+          prepareDiagnosticEventSpy,
+          {
             canProceed: true,
             eventData: {
               webClientDomain: 'whatever',
@@ -2130,37 +2569,244 @@ describe('internal-plugin-metrics', () => {
               correlationId: 'correlationId',
               webexConferenceIdStr: 'webexConferenceIdStr1',
               globalMeetingId: 'globalMeetingId1',
+              sessionCorrelationId: 'sessionCorrelationId1',
               deviceId: 'deviceUrl',
               locusId: 'url',
               locusSessionId: 'locusSessionId',
               locusStartTime: 'lastActive',
               locusUrl: 'locus/url',
-              mediaAgentAlias: 'alias',
-              mediaAgentGroupId: '1',
               orgId: 'orgId',
               userId: 'userId',
             },
-            errors: [
-              {
-                category: 'expected',
-                errorDescription: 'StartRecordingFailed',
-                fatal: true,
-                name: 'other',
-                shownToUser: false,
-                serviceErrorCode: 2409005,
-                errorCode: 4029,
-                rawErrorMessage: undefined,
-              },
-            ],
             loginType: 'login-ci',
+            telemetryOptOut: undefined,
             name: 'client.alert.displayed',
             userType: 'host',
             isConvergedArchitectureEnabled: undefined,
             webexSubServiceType: undefined,
             webClientPreload: undefined,
+            isVipMeeting: false,
+            isAutomatedUser: false,
+            userActivation: undefined,
           },
-          eventId: 'my-fake-id',
-          origin: {
+          options
+        );
+        assert.calledWith(submitToCallDiagnosticsSpy, {
+          event: {
+            canProceed: true,
+            eventData: {
+              webClientDomain: 'whatever',
+              isMercuryConnected: true,
+            },
+            identifiers: {
+              correlationId: 'correlationId',
+              webexConferenceIdStr: 'webexConferenceIdStr1',
+              globalMeetingId: 'globalMeetingId1',
+              sessionCorrelationId: 'sessionCorrelationId1',
+              deviceId: 'deviceUrl',
+              locusId: 'url',
+              locusSessionId: 'locusSessionId',
+              locusStartTime: 'lastActive',
+              locusUrl: 'locus/url',
+              orgId: 'orgId',
+              userId: 'userId',
+            },
+            loginType: 'login-ci',
+            telemetryOptOut: undefined,
+            name: 'client.alert.displayed',
+            userType: 'host',
+            isConvergedArchitectureEnabled: undefined,
+            webexSubServiceType: undefined,
+            webClientPreload: undefined,
+            isVipMeeting: false,
+            isAutomatedUser: false,
+            userActivation: undefined,
+          },
+          eventId: 'my-fake-id',
+          origin: {
+            origin: 'fake-origin',
+          },
+          originTime: {
+            sent: 'not_defined_yet',
+            triggered: now.toISOString(),
+          },
+          senderCountryCode: 'UK',
+          version: 1,
+        });
+      });
+
+      it('should submit client event with isVipMeeting: true when vipMeeting is true', () => {
+        const prepareDiagnosticEventSpy = sinon.spy(cd, 'prepareDiagnosticEvent');
+        const submitToCallDiagnosticsSpy = sinon.spy(cd, 'submitToCallDiagnostics');
+        const generateClientEventErrorPayloadSpy = sinon.spy(cd, 'generateClientEventErrorPayload');
+        sinon.stub(cd, 'getOrigin').returns({origin: 'fake-origin'});
+
+        webex.meetings.getBasicMeetingInformation = sinon.stub().returns({
+          ...fakeMeeting,
+          meetingInfo: {
+            vipmeeting: true,
+          },
+        });
+
+        const options = {
+          correlationId: 'correlationId',
+          webexConferenceIdStr: 'webexConferenceIdStr1',
+          globalMeetingId: 'globalMeetingId1',
+          sessionCorrelationId: 'sessionCorrelationId1',
+          meetingId: fakeMeeting.id,
+        };
+        cd.setMercuryConnectedStatus(true);
+        cd.submitClientEvent({
+          name: 'client.alert.displayed',
+          options,
+        });
+
+        assert.notCalled(generateClientEventErrorPayloadSpy);
+        assert.calledWith(
+          prepareDiagnosticEventSpy,
+          {
+            canProceed: true,
+            eventData: {
+              webClientDomain: 'whatever',
+              isMercuryConnected: true,
+            },
+            identifiers: {
+              correlationId: 'correlationId',
+              webexConferenceIdStr: 'webexConferenceIdStr1',
+              globalMeetingId: 'globalMeetingId1',
+              sessionCorrelationId: 'sessionCorrelationId1',
+              deviceId: 'deviceUrl',
+              locusId: 'url',
+              locusSessionId: 'locusSessionId',
+              locusStartTime: 'lastActive',
+              locusUrl: 'locus/url',
+              orgId: 'orgId',
+              userId: 'userId',
+            },
+            loginType: 'login-ci',
+            telemetryOptOut: undefined,
+            name: 'client.alert.displayed',
+            userType: 'host',
+            isConvergedArchitectureEnabled: undefined,
+            webexSubServiceType: undefined,
+            webClientPreload: undefined,
+            isVipMeeting: true,
+            isAutomatedUser: false,
+            userActivation: undefined,
+          },
+          options
+        );
+        assert.calledWith(submitToCallDiagnosticsSpy, {
+          event: {
+            canProceed: true,
+            eventData: {
+              webClientDomain: 'whatever',
+              isMercuryConnected: true,
+            },
+            identifiers: {
+              correlationId: 'correlationId',
+              webexConferenceIdStr: 'webexConferenceIdStr1',
+              globalMeetingId: 'globalMeetingId1',
+              sessionCorrelationId: 'sessionCorrelationId1',
+              deviceId: 'deviceUrl',
+              locusId: 'url',
+              locusSessionId: 'locusSessionId',
+              locusStartTime: 'lastActive',
+              locusUrl: 'locus/url',
+              orgId: 'orgId',
+              userId: 'userId',
+            },
+            loginType: 'login-ci',
+            telemetryOptOut: undefined,
+            name: 'client.alert.displayed',
+            userType: 'host',
+            isConvergedArchitectureEnabled: undefined,
+            webexSubServiceType: undefined,
+            webClientPreload: undefined,
+            isVipMeeting: true,
+            isAutomatedUser: false,
+            userActivation: undefined,
+          },
+          eventId: 'my-fake-id',
+          origin: {
+            origin: 'fake-origin',
+          },
+          originTime: {
+            sent: 'not_defined_yet',
+            triggered: now.toISOString(),
+          },
+          senderCountryCode: 'UK',
+          version: 1,
+        });
+      });
+
+      it('it should include errors if provided with meetingId', () => {
+        sinon.stub(cd, 'getOrigin').returns({origin: 'fake-origin'});
+        const submitToCallDiagnosticsSpy = sinon.spy(cd, 'submitToCallDiagnostics');
+
+        const options = {
+          meetingId: fakeMeeting.id,
+          webexConferenceIdStr: 'webexConferenceIdStr1',
+          globalMeetingId: 'globalMeetingId1',
+          mediaConnections: [{mediaAgentAlias: 'alias', mediaAgentGroupId: '1'}],
+          rawError: {
+            body: {
+              errorCode: 2409005,
+            },
+          },
+        };
+        cd.setMercuryConnectedStatus(true);
+        cd.submitClientEvent({
+          name: 'client.alert.displayed',
+          options,
+        });
+
+        assert.calledWith(submitToCallDiagnosticsSpy, {
+          event: {
+            canProceed: true,
+            eventData: {
+              webClientDomain: 'whatever',
+              isMercuryConnected: true,
+            },
+            identifiers: {
+              correlationId: 'correlationId',
+              webexConferenceIdStr: 'webexConferenceIdStr1',
+              globalMeetingId: 'globalMeetingId1',
+              deviceId: 'deviceUrl',
+              locusId: 'url',
+              locusSessionId: 'locusSessionId',
+              locusStartTime: 'lastActive',
+              locusUrl: 'locus/url',
+              mediaAgentAlias: 'alias',
+              mediaAgentGroupId: '1',
+              orgId: 'orgId',
+              userId: 'userId',
+            },
+            errors: [
+              {
+                category: 'expected',
+                errorDescription: 'StartRecordingFailed',
+                fatal: true,
+                name: 'other',
+                shownToUser: false,
+                serviceErrorCode: 2409005,
+                errorCode: 4029,
+                rawErrorMessage: undefined,
+              },
+            ],
+            loginType: 'login-ci',
+            telemetryOptOut: undefined,
+            name: 'client.alert.displayed',
+            userType: 'host',
+            isConvergedArchitectureEnabled: undefined,
+            webexSubServiceType: undefined,
+            webClientPreload: undefined,
+            isVipMeeting: false,
+            isAutomatedUser: false,
+            userActivation: undefined,
+          },
+          eventId: 'my-fake-id',
+          origin: {
             origin: 'fake-origin',
           },
           originTime: {
@@ -2235,11 +2881,15 @@ describe('internal-plugin-metrics', () => {
               },
             ],
             loginType: 'login-ci',
+            telemetryOptOut: undefined,
             name: 'client.alert.displayed',
             userType: 'host',
             isConvergedArchitectureEnabled: undefined,
             webexSubServiceType: undefined,
             webClientPreload: undefined,
+            isVipMeeting: false,
+            isAutomatedUser: false,
+            userActivation: undefined,
           },
           eventId: 'my-fake-id',
           origin: {
@@ -2311,8 +2961,12 @@ describe('internal-plugin-metrics', () => {
               },
             ],
             loginType: 'login-ci',
+            telemetryOptOut: undefined,
             name: 'client.alert.displayed',
             webClientPreload: undefined,
+            isAutomatedUser: false,
+            userActivation: undefined,
+            meetingJoinPhase: 'pre-join',
           },
           eventId: 'my-fake-id',
           origin: {
@@ -2386,8 +3040,12 @@ describe('internal-plugin-metrics', () => {
               },
             ],
             loginType: 'login-ci',
+            telemetryOptOut: undefined,
             name: 'client.alert.displayed',
             webClientPreload: undefined,
+            isAutomatedUser: false,
+            userActivation: undefined,
+            meetingJoinPhase: 'pre-join',
           },
           eventId: 'my-fake-id',
           origin: {
@@ -2468,11 +3126,15 @@ describe('internal-plugin-metrics', () => {
               },
             ],
             loginType: 'login-ci',
+            telemetryOptOut: undefined,
             name: 'client.alert.displayed',
             userType: 'host',
             isConvergedArchitectureEnabled: undefined,
             webexSubServiceType: undefined,
             webClientPreload: undefined,
+            isVipMeeting: false,
+            isAutomatedUser: false,
+            userActivation: undefined,
           },
           eventId: 'my-fake-id',
           origin: {
@@ -2563,16 +3225,18 @@ describe('internal-plugin-metrics', () => {
           });
 
           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]) => {
+        (
+          [
+            ['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,
@@ -2616,7 +3280,8 @@ describe('internal-plugin-metrics', () => {
             });
 
             assert.notCalled(submitToCallDiagnosticsStub);
-            assert.neverCalledWithMatch(webex.logger.log,
+            assert.neverCalledWithMatch(
+              webex.logger.log,
               'call-diagnostic-events -> ',
               sinon.match(createEventLimitRegex(name, 'mediaType video'))
             );
@@ -2659,7 +3324,7 @@ describe('internal-plugin-metrics', () => {
             // Send event with different shareInstanceId
             cd.submitClientEvent({
               name,
-              payload: { ...payload, shareInstanceId: 'instance-2' },
+              payload: {...payload, shareInstanceId: 'instance-2'},
               options,
             });
 
@@ -2667,89 +3332,88 @@ describe('internal-plugin-metrics', () => {
           });
         });
 
-        ([
-          ['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,
+        ([['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'))
+              );
             });
 
-            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');
 
-          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,
-            });
+              cd.submitClientEvent({
+                name,
+                payload,
+                options,
+              });
 
-            cd.submitClientEvent({
-              name,
-              payload,
-              options,
+              assert.calledOnce(submitToCallDiagnosticsStub);
             });
-
-            assert.calledOnce(submitToCallDiagnosticsStub);
-          });
-        });
+          }
+        );
       });
     });
 
@@ -2760,7 +3424,10 @@ describe('internal-plugin-metrics', () => {
         cd.callDiagnosticEventsBatcher = {request: requestStub};
         //@ts-ignore
         cd.submitToCallDiagnostics({event: 'test'});
-        assert.calledWith(requestStub, {eventPayload: {event: 'test'}, type: ['diagnostic-event']});
+        assert.calledWith(requestStub, {
+          eventPayload: {event: 'test'},
+          type: ['diagnostic-event'],
+        });
       });
     });
 
@@ -2829,6 +3496,7 @@ describe('internal-plugin-metrics', () => {
               mediaEngineSoftwareVersion: getOSVersion() || 'unknown',
               startTime: now.toISOString(),
             },
+            webexSubServiceType: undefined,
           },
           options
         );
@@ -2869,6 +3537,7 @@ describe('internal-plugin-metrics', () => {
                 mediaEngineSoftwareVersion: getOSVersion() || 'unknown',
                 startTime: now.toISOString(),
               },
+              webexSubServiceType: undefined,
             },
           },
         });
@@ -2907,10 +3576,48 @@ describe('internal-plugin-metrics', () => {
               mediaEngineSoftwareVersion: getOSVersion() || 'unknown',
               startTime: now.toISOString(),
             },
+            webexSubServiceType: undefined,
           },
         });
       });
 
+      it('includes webexSubServiceType in the media quality event payload', () => {
+        const meeting = {
+          ...fakeMeeting,
+          meetingInfo: {
+            enableConvergedArchitecture: true,
+            enableEvent: true,
+            enableConvergedWebinarLargeScale: true,
+          },
+        };
+        const prepareDiagnosticEventSpy = sinon.spy(cd, 'prepareDiagnosticEvent');
+        sinon.stub(cd, 'getOrigin').returns({origin: 'fake-origin'});
+        webex.meetings.getBasicMeetingInformation = sinon.stub().returns(meeting);
+
+        const options = {
+          networkType: 'wifi' as const,
+          meetingId: fakeMeeting.id,
+        };
+
+        cd.submitMQE({
+          name: 'client.mediaquality.event',
+          payload: {
+            //@ts-ignore
+            intervals: [{}],
+          },
+          options,
+        });
+
+        assert.calledOnceWithExactly(
+          prepareDiagnosticEventSpy,
+          sinon.match({
+            name: 'client.mediaquality.event',
+            webexSubServiceType: 'LargeScaleWebinar',
+          }),
+          options
+        );
+      });
+
       it('throws if meeting id not provided', () => {
         assert.throws(() =>
           cd.submitMQE({
@@ -3190,7 +3897,7 @@ describe('internal-plugin-metrics', () => {
           serviceErrorCode: undefined,
           errorCode: 1026,
           rawErrorMessage: '{}\nundefined https://example.com\nWEBEX_TRACKING_ID: undefined\n',
-          httpStatusCode: 0,
+          httpCode: 0,
         });
       });
 
@@ -3307,7 +4014,7 @@ describe('internal-plugin-metrics', () => {
           serviceErrorCode: undefined,
           errorCode: 1026,
           rawErrorMessage: '{}\nundefined https://example.com\nWEBEX_TRACKING_ID: undefined\n',
-          httpStatusCode: 0,
+          httpCode: 0,
         });
       });
 
@@ -3329,7 +4036,7 @@ describe('internal-plugin-metrics', () => {
           serviceErrorCode: undefined,
           errorCode: 1010,
           rawErrorMessage: '{}\nundefined https://example.com\nWEBEX_TRACKING_ID: undefined\n',
-          httpStatusCode: 0,
+          httpCode: 0,
         });
       });
 
@@ -3355,7 +4062,7 @@ describe('internal-plugin-metrics', () => {
           serviceErrorCode: undefined,
           errorCode: 1010,
           rawErrorMessage: '{}\nundefined https://example.com\nWEBEX_TRACKING_ID: undefined\n',
-          httpStatusCode: 0,
+          httpCode: 0,
         });
       });
 
@@ -3460,8 +4167,144 @@ describe('internal-plugin-metrics', () => {
         });
       });
 
-      describe('httpStatusCode', () => {
-        it('should include httpStatusCode for browser media errors', () => {
+      describe('httpCode', () => {
+        it('should identify an outgoing Locus 429', () => {
+          const rawErrorMessage =
+            'partition 371 on PARALLEL_EXECUTOR_PARTITION_KEY_QUEUE_FULL state';
+          const [res] = cd.generateClientEventErrorPayload({
+            message: rawErrorMessage,
+            statusCode: 429,
+            options: {uri: 'https://locus.example.com/locus/api/v1/loci/call'},
+          });
+
+          assert.deepEqual(res, {
+            category: 'signaling',
+            errorCode: 1002,
+            errorDescription: 'LocusRateLimitedOutgoing',
+            fatal: true,
+            name: 'locus.response',
+            rawErrorMessage,
+            serviceErrorCode: undefined,
+            shownToUser: false,
+            httpCode: 429,
+          });
+        });
+
+        [
+          ['media', 'https://example.com/locus/api/v1/loci/123/media'],
+          ['hashtree', 'https://example.com/locus/api/v1/loci/123/hashtree'],
+          ['host-only Locus URL', 'https://locus.example.com/api/v1/resource'],
+          ['query-only Locus URL', 'https://example.com/api/v1/resource?service=locus'],
+        ].forEach(([operation, uri]) => {
+          it(`should identify a Locus 429 for ${operation}`, () => {
+            const [res] = cd.generateClientEventErrorPayload({
+              message: 'Locus rate limited',
+              statusCode: 429,
+              options: {uri},
+            });
+
+            assert.equal(res.errorCode, 1002);
+            assert.equal(res.errorDescription, 'LocusRateLimitedOutgoing');
+            assert.equal(res.httpCode, 429);
+          });
+        });
+
+        it('should identify an unavailable Locus 503', () => {
+          const rawErrorMessage = 'Service unavailable';
+          const [res] = cd.generateClientEventErrorPayload({
+            message: rawErrorMessage,
+            statusCode: 503,
+            options: {uri: 'https://locus.example.com/locus/api/v1/loci/call'},
+          });
+
+          assert.deepEqual(res, {
+            category: 'signaling',
+            errorCode: 1003,
+            errorDescription: 'LocusUnavailable',
+            fatal: true,
+            name: 'locus.response',
+            rawErrorMessage,
+            serviceErrorCode: undefined,
+            shownToUser: false,
+            httpCode: 503,
+          });
+        });
+
+        it('should prefer a specific service error mapping over the Locus HTTP status', () => {
+          const rawErrorMessage = 'Fraud detected';
+          const [res] = cd.generateClientEventErrorPayload({
+            body: {errorCode: 2423012},
+            message: rawErrorMessage,
+            statusCode: 429,
+            options: {uri: 'https://locus.example.com/locus/api/v1/loci/call'},
+          });
+
+          assert.deepEqual(res, {
+            category: 'expected',
+            errorCode: 12000,
+            errorDescription: 'FraudDetection',
+            fatal: true,
+            name: 'locus.response',
+            rawErrorMessage,
+            serviceErrorCode: 2423012,
+            shownToUser: true,
+            httpCode: 429,
+          });
+        });
+
+        it('should retain an unmapped service error code on the Locus HTTP status payload', () => {
+          const rawErrorMessage = 'Locus rate limited';
+          const [res] = cd.generateClientEventErrorPayload({
+            body: {errorCode: 2429999},
+            message: rawErrorMessage,
+            statusCode: 429,
+            options: {uri: 'https://locus.example.com/locus/api/v1/loci/call'},
+          });
+
+          assert.deepEqual(res, {
+            category: 'signaling',
+            errorCode: 1002,
+            errorDescription: 'LocusRateLimitedOutgoing',
+            fatal: true,
+            name: 'locus.response',
+            rawErrorMessage,
+            serviceErrorCode: 2429999,
+            shownToUser: false,
+            httpCode: 429,
+          });
+        });
+
+        it('should not identify a non-Locus 429 as a Locus rate limit', () => {
+          const [res] = cd.generateClientEventErrorPayload({
+            message: 'Too many requests',
+            statusCode: 429,
+            options: {uri: 'https://example.com/api/v1/resource'},
+          });
+
+          assert.deepEqual(res, {
+            category: 'other',
+            errorCode: 9999,
+            errorDescription: 'UnknownError',
+            fatal: true,
+            name: 'other',
+            rawErrorMessage: 'Too many requests',
+            serviceErrorCode: 9999,
+            shownToUser: false,
+            httpCode: 429,
+          });
+        });
+
+        it('should keep the fallback classification when a 429 has no request URL', () => {
+          const [res] = cd.generateClientEventErrorPayload({
+            message: 'Too many requests',
+            statusCode: 429,
+          });
+
+          assert.equal(res.errorCode, 9999);
+          assert.equal(res.httpCode, 429);
+        });
+
+        it('should include httpCode for browser media errors', () => {
           const [res, cached] = cd.generateClientEventErrorPayload({
             name: 'PermissionDeniedError',
             message: 'bad times',
@@ -3479,11 +4322,11 @@ describe('internal-plugin-metrics', () => {
             rawErrorMessage: 'bad times',
             serviceErrorCode: undefined,
             shownToUser: false,
-            httpStatusCode: 401,
+            httpCode: 401,
           });
         });
 
-        it('should include httpStatusCode for SdpOfferCreationErrors', () => {
+        it('should include httpCode for SdpOfferCreationErrors', () => {
           const [res, cached] = cd.generateClientEventErrorPayload({
             name: 'SdpOfferCreationError',
             message: 'bad times',
@@ -3501,11 +4344,11 @@ describe('internal-plugin-metrics', () => {
             rawErrorMessage: 'bad times',
             serviceErrorCode: undefined,
             shownToUser: true,
-            httpStatusCode: 404,
+            httpCode: 404,
           });
         });
 
-        it('should include httpStatusCode for service error codes', () => {
+        it('should include httpCode for service error codes', () => {
           const [res, cached] = cd.generateClientEventErrorPayload({
             body: {errorCode: 58400},
             message: 'bad times',
@@ -3520,11 +4363,11 @@ describe('internal-plugin-metrics', () => {
             rawErrorMessage: 'bad times',
             serviceErrorCode: 58400,
             shownToUser: false,
-            httpStatusCode: 400,
+            httpCode: 400,
           });
         });
 
-        it('should include httpStatusCode for locus service error codes', () => {
+        it('should include httpCode for locus service error codes', () => {
           const [res, cached] = cd.generateClientEventErrorPayload({
             body: {errorCode: 2403001},
             message: 'bad times',
@@ -3539,11 +4382,11 @@ describe('internal-plugin-metrics', () => {
             rawErrorMessage: 'bad times',
             serviceErrorCode: 2403001,
             shownToUser: false,
-            httpStatusCode: 400,
+            httpCode: 400,
           });
         });
 
-        it('should include httpStatusCode for meetingInfo service error codes', () => {
+        it('should include httpCode for meetingInfo service error codes', () => {
           const [res, cached] = cd.generateClientEventErrorPayload({
             body: {data: {meetingInfo: {}}},
             message: 'bad times',
@@ -3558,11 +4401,11 @@ describe('internal-plugin-metrics', () => {
             rawErrorMessage: 'bad times',
             serviceErrorCode: undefined,
             shownToUser: false,
-            httpStatusCode: 400,
+            httpCode: 400,
           });
         });
 
-        it('should include httpStatusCode for network errors', () => {
+        it('should include httpCode for network errors', () => {
           const error = new WebexHttpError.NetworkOrCORSError({
             statusCode: 400,
             options: {service: '', headers: {}},
@@ -3577,11 +4420,11 @@ describe('internal-plugin-metrics', () => {
             rawErrorMessage: 'undefined\nundefined /undefined\nWEBEX_TRACKING_ID: undefined\n',
             serviceErrorCode: undefined,
             shownToUser: false,
-            httpStatusCode: 400,
+            httpCode: 400,
           });
         });
 
-        it('should include httpStatusCode for unauthorized errors', () => {
+        it('should include httpCode for unauthorized errors', () => {
           const error = new WebexHttpError.Unauthorized({
             statusCode: 401,
             options: {service: '', headers: {}},
@@ -3596,11 +4439,11 @@ describe('internal-plugin-metrics', () => {
             rawErrorMessage: 'undefined\nundefined /undefined\nWEBEX_TRACKING_ID: undefined\n',
             serviceErrorCode: undefined,
             shownToUser: false,
-            httpStatusCode: 401,
+            httpCode: 401,
           });
         });
 
-        it('should include httpStatusCode for unknown errors', () => {
+        it('should include httpCode for unknown errors', () => {
           const [res, cached] = cd.generateClientEventErrorPayload({
             message: 'bad times',
             statusCode: 404,
@@ -3614,7 +4457,7 @@ describe('internal-plugin-metrics', () => {
             serviceErrorCode: 9999,
             errorDescription: 'UnknownError',
             rawErrorMessage: 'bad times',
-            httpStatusCode: 404,
+            httpCode: 404,
           });
         });
       });
@@ -3631,6 +4474,97 @@ describe('internal-plugin-metrics', () => {
       });
     });
 
+    describe('#getTelemetryOptOut', () => {
+      it('returns "manual" when manual telemetry opt-out is enabled', () => {
+        cd.setIsTelemetryOptOutManual(true);
+        assert.equal(cd.getTelemetryOptOut(), 'manual');
+      });
+
+      it('returns "automatic" when automatic telemetry opt-out is enabled', () => {
+        cd.setIsTelemetryOptOutAutomatic(true);
+        assert.equal(cd.getTelemetryOptOut(), 'automatic');
+      });
+
+      it('returns "manual" when manual opt-out takes precedence over automatic', () => {
+        cd.setIsTelemetryOptOutManual(true);
+        cd.setIsTelemetryOptOutAutomatic(true);
+        assert.equal(cd.getTelemetryOptOut(), 'manual');
+      });
+
+      it('returns undefined when neither manual nor automatic opt-out is set', () => {
+        assert.isUndefined(cd.getTelemetryOptOut());
+      });
+
+      it('returns undefined after disabling manual opt-out', () => {
+        cd.setIsTelemetryOptOutManual(true);
+        cd.setIsTelemetryOptOutManual(false);
+        assert.isUndefined(cd.getTelemetryOptOut());
+      });
+    });
+
+    describe('#setIsTelemetryOptOutManual', () => {
+      it('sets manual telemetry opt-out to true', () => {
+        cd.setIsTelemetryOptOutManual(true);
+        assert.equal(cd.getTelemetryOptOut(), 'manual');
+      });
+
+      it('sets manual telemetry opt-out to false', () => {
+        cd.setIsTelemetryOptOutManual(true);
+        cd.setIsTelemetryOptOutManual(false);
+        assert.isUndefined(cd.getTelemetryOptOut());
+      });
+
+      it('can toggle manual telemetry opt-out multiple times', () => {
+        cd.setIsTelemetryOptOutManual(true);
+        assert.equal(cd.getTelemetryOptOut(), 'manual');
+
+        cd.setIsTelemetryOptOutManual(false);
+        assert.isUndefined(cd.getTelemetryOptOut());
+
+        cd.setIsTelemetryOptOutManual(true);
+        assert.equal(cd.getTelemetryOptOut(), 'manual');
+      });
+
+      it('manual opt-out takes precedence when automatic is also set', () => {
+        cd.setIsTelemetryOptOutAutomatic(true);
+        cd.setIsTelemetryOptOutManual(true);
+        assert.equal(cd.getTelemetryOptOut(), 'manual');
+      });
+    });
+
+    describe('#setIsTelemetryOptOutAutomatic', () => {
+      it('sets automatic telemetry opt-out to true', () => {
+        cd.setIsTelemetryOptOutAutomatic(true);
+        assert.equal(cd.getTelemetryOptOut(), 'automatic');
+      });
+
+      it('sets automatic telemetry opt-out to false', () => {
+        cd.setIsTelemetryOptOutAutomatic(true);
+        cd.setIsTelemetryOptOutAutomatic(false);
+        assert.isUndefined(cd.getTelemetryOptOut());
+      });
+
+      it('can toggle automatic telemetry opt-out multiple times', () => {
+        cd.setIsTelemetryOptOutAutomatic(true);
+        assert.equal(cd.getTelemetryOptOut(), 'automatic');
+
+        cd.setIsTelemetryOptOutAutomatic(false);
+        assert.isUndefined(cd.getTelemetryOptOut());
+
+        cd.setIsTelemetryOptOutAutomatic(true);
+        assert.equal(cd.getTelemetryOptOut(), 'automatic');
+      });
+
+      it('does not override manual opt-out', () => {
+        cd.setIsTelemetryOptOutManual(true);
+        cd.setIsTelemetryOptOutAutomatic(true);
+        assert.equal(cd.getTelemetryOptOut(), 'manual');
+
+        cd.setIsTelemetryOptOutAutomatic(false);
+        assert.equal(cd.getTelemetryOptOut(), 'manual');
+      });
+    });
+
     describe('#getSubServiceType', () => {
       it('returns subServicetype as PMR when PMR meeting', () => {
         fakeMeeting.meetingInfo = {
@@ -3680,6 +4614,15 @@ describe('internal-plugin-metrics', () => {
         assert.deepEqual(cd.getSubServiceType(fakeMeeting), 'Webcast');
       });
 
+      it('returns subServicetype as LargeScaleWebinar when meeting is converged Webinar and enable large scale', () => {
+        fakeMeeting.meetingInfo = {
+          enableEvent: true,
+          enableConvergedArchitecture: true,
+          enableConvergedWebinarLargeScale: true,
+        };
+        assert.deepEqual(cd.getSubServiceType(fakeMeeting), 'LargeScaleWebinar');
+      });
+
       it('returns subServicetype as undefined when correct parameters are not found', () => {
         fakeMeeting.meetingInfo = {};
         assert.deepEqual(cd.getSubServiceType(fakeMeeting), undefined);
@@ -3705,6 +4648,18 @@ describe('internal-plugin-metrics', () => {
     });
 
     describe('#buildClientEventFetchRequestOptions', () => {
+      it('should add the locusCluster option to a pre-meeting event', async () => {
+        const fetchOptions = await cd.buildClientEventFetchRequestOptions({
+          name: 'client.interstitial-window.launched',
+          options: {correlationId: 'correlationId', locusCluster: 'locus-k.wbx2.com'},
+        });
+
+        assert.equal(
+          fetchOptions.body.metrics[0].eventPayload.event.identifiers.locusCluster,
+          'locus-k.wbx2.com'
+        );
+      });
+
       [undefined, 'myPreLoginId'].forEach((preLoginId) => {
         it('returns expected options without preLoginId', async () => {
           const options = {
@@ -3740,12 +4695,16 @@ describe('internal-plugin-metrics', () => {
                       userId: 'userId',
                     },
                     loginType: 'login-ci',
+                    telemetryOptOut: undefined,
                     name: 'client.exit.app',
                     trigger: 'user-interaction',
                     userType: 'host',
                     isConvergedArchitectureEnabled: undefined,
                     webexSubServiceType: undefined,
                     webClientPreload: undefined,
+                    isVipMeeting: false,
+                    isAutomatedUser: false,
+                    userActivation: undefined,
                   },
                   eventId: 'my-fake-id',
                   origin: {
@@ -3900,6 +4859,80 @@ describe('internal-plugin-metrics', () => {
           options.meetingJoinPhase
         );
       });
+
+      it('includes expected meetingJoinPhase from meeting callStateForMetrics when in-meeting', async () => {
+        // meetingId means in-meeting
+        const options = {
+          meetingId: fakeMeeting6.id,
+        };
+
+        const fetchOptions = await cd.buildClientEventFetchRequestOptions({
+          name: 'client.exit.app',
+          payload: {trigger: 'user-interaction', canProceed: false},
+          options,
+        });
+
+        assert.equal(fetchOptions.body.metrics[0].eventPayload.event.meetingJoinPhase, 'in-meeting');
+      });
+
+      it('prioritizes meetingJoinPhase from options over meeting callStateForMetrics', async () => {
+        // meetingId means in-meeting
+        const options = {
+          meetingId: fakeMeeting6.id,
+          meetingJoinPhase: 'join',
+        };
+
+        const fetchOptions = await cd.buildClientEventFetchRequestOptions({
+          name: 'client.exit.app',
+          payload: {trigger: 'user-interaction', canProceed: false},
+          options,
+        });
+
+        assert.equal(
+          fetchOptions.body.metrics[0].eventPayload.event.meetingJoinPhase,
+          options.meetingJoinPhase
+        );
+      });
+
+      it('defaults meetingJoinPhase to pre-join during prejoin when not provided in options', async () => {
+        // correlationId and no meeting id means prejoin
+        const options = {
+          correlationId: 'myCorrelationId',
+          preLoginId: 'myPreLoginId',
+        };
+
+        const fetchOptions = await cd.buildClientEventFetchRequestOptions({
+          name: 'client.exit.app',
+          payload: {trigger: 'user-interaction', canProceed: false},
+          options,
+        });
+
+        assert.equal(fetchOptions.body.metrics[0].eventPayload.event.meetingJoinPhase, 'pre-join');
+      });
+
+      it('builds request options before webex is ready (no meetings plugin or internal metrics config)', async () => {
+        // before webex.ready the meetings plugin and internal metrics config are not available
+        webex.meetings = undefined;
+        webex.internal.metrics = undefined;
+
+        const options = {
+          correlationId: 'myCorrelationId',
+          clientType: 'TEAMS_CLIENT',
+          subClientType: 'WEB_APP',
+        };
+
+        const fetchOptions = await cd.buildClientEventFetchRequestOptions({
+          name: 'client.exit.app',
+          payload: {trigger: 'user-interaction', canProceed: false},
+          options,
+        });
+
+        const eventPayload = fetchOptions.body.metrics[0].eventPayload;
+        assert.equal(eventPayload.event.name, 'client.exit.app');
+        assert.isUndefined(eventPayload.senderCountryCode);
+        assert.isUndefined(fetchOptions.waitForServiceTimeout);
+        assert.equal(fetchOptions.resource, 'clientmetrics');
+      });
     });
 
     describe('#submitToCallDiagnosticsPreLogin', () => {
@@ -3913,7 +4946,10 @@ describe('internal-plugin-metrics', () => {
         cd.submitToCallDiagnosticsPreLogin({event: 'test'}, preLoginId);
         //@ts-ignore
         assert.calledWith(cd.preLoginMetricsBatcher.savePreLoginId, preLoginId);
-        assert.calledWith(requestStub, {eventPayload: {event: 'test'}, type: ['diagnostic-event']});
+        assert.calledWith(requestStub, {
+          eventPayload: {event: 'test'},
+          type: ['diagnostic-event'],
+        });
       });
     });
 
@@ -4114,12 +5150,14 @@ describe('internal-plugin-metrics', () => {
           payload: {
             meetingSummaryInfo: {
               featureName: 'syncSystemMuteStatus',
-              featureActions: [{
-                actionName: 'syncMeetingMicUnmuteStatusToSystem',
-                actionId: '14200',
-                isInitialValue: false,
-                clickCount: '1'
-              }]
+              featureActions: [
+                {
+                  actionName: 'syncMeetingMicUnmuteStatusToSystem',
+                  actionId: '14200',
+                  isInitialValue: false,
+                  clickCount: '1',
+                },
+              ],
             },
           },
           options,
@@ -4140,22 +5178,28 @@ describe('internal-plugin-metrics', () => {
               locusSessionId: 'locusSessionId',
               locusStartTime: 'lastActive',
             },
-            eventData: { webClientDomain: 'whatever'},
+            eventData: {webClientDomain: 'whatever'},
             userType: 'host',
             loginType: 'login-ci',
+            telemetryOptOut: undefined,
             isConvergedArchitectureEnabled: undefined,
             webexSubServiceType: undefined,
             webClientPreload: undefined,
+            isVipMeeting: false,
+            isAutomatedUser: false,
+            userActivation: undefined,
             meetingSummaryInfo: {
               featureName: 'syncSystemMuteStatus',
-              featureActions: [{
-                actionName: 'syncMeetingMicUnmuteStatusToSystem',
-                actionId: '14200',
-                isInitialValue: false,
-                clickCount: '1'
-              }]
+              featureActions: [
+                {
+                  actionName: 'syncMeetingMicUnmuteStatusToSystem',
+                  actionId: '14200',
+                  isInitialValue: false,
+                  clickCount: '1',
+                },
+              ],
             },
-            key: "UcfFeatureUsage",
+            key: 'UcfFeatureUsage',
           },
           options
         );
@@ -4168,7 +5212,7 @@ describe('internal-plugin-metrics', () => {
           },
           event: {
             canProceed: true,
-            eventData: { webClientDomain: 'whatever'},
+            eventData: {webClientDomain: 'whatever'},
             identifiers: {
               correlationId: 'correlationId',
               deviceId: 'deviceUrl',
@@ -4180,21 +5224,27 @@ describe('internal-plugin-metrics', () => {
               userId: 'userId',
             },
             loginType: 'login-ci',
+            telemetryOptOut: undefined,
             name: 'client.feature.meeting.summary',
             userType: 'host',
             isConvergedArchitectureEnabled: undefined,
             webexSubServiceType: undefined,
             webClientPreload: undefined,
+            isVipMeeting: false,
+            isAutomatedUser: false,
+            userActivation: undefined,
             meetingSummaryInfo: {
               featureName: 'syncSystemMuteStatus',
-              featureActions: [{
-                actionName: 'syncMeetingMicUnmuteStatusToSystem',
-                actionId: '14200',
-                isInitialValue: false,
-                clickCount: '1'
-              }]
+              featureActions: [
+                {
+                  actionName: 'syncMeetingMicUnmuteStatusToSystem',
+                  actionId: '14200',
+                  isInitialValue: false,
+                  clickCount: '1',
+                },
+              ],
             },
-            key: "UcfFeatureUsage",
+            key: 'UcfFeatureUsage',
           },
           originTime: {
             sent: 'not_defined_yet',
@@ -4235,12 +5285,14 @@ describe('internal-plugin-metrics', () => {
           payload: {
             meetingSummaryInfo: {
               featureName: 'syncSystemMuteStatus',
-              featureActions: [{
-                actionName: 'syncMeetingMicUnmuteStatusToSystem',
-                actionId: '14200',
-                isInitialValue: false,
-                clickCount: '1'
-              }]
+              featureActions: [
+                {
+                  actionName: 'syncMeetingMicUnmuteStatusToSystem',
+                  actionId: '14200',
+                  isInitialValue: false,
+                  clickCount: '1',
+                },
+              ],
             },
           },
           delaySubmitEvent: true,
@@ -4252,12 +5304,14 @@ describe('internal-plugin-metrics', () => {
           payload: {
             meetingSummaryInfo: {
               featureName: 'syncSystemVideoStatus',
-              featureActions: [{
-                actionName: 'syncMeetingVideoUnmuteStatusToSystem',
-                actionId: '13400',
-                isInitialValue: false,
-                clickCount: '1'
-              }]
+              featureActions: [
+                {
+                  actionName: 'syncMeetingVideoUnmuteStatusToSystem',
+                  actionId: '13400',
+                  isInitialValue: false,
+                  clickCount: '1',
+                },
+              ],
             },
           },
           delaySubmitEvent: true,
@@ -4275,12 +5329,14 @@ describe('internal-plugin-metrics', () => {
           payload: {
             meetingSummaryInfo: {
               featureName: 'syncSystemMuteStatus',
-              featureActions: [{
-                actionName: 'syncMeetingMicUnmuteStatusToSystem',
-                actionId: '14200',
-                isInitialValue: false,
-                clickCount: '1'
-              }]
+              featureActions: [
+                {
+                  actionName: 'syncMeetingMicUnmuteStatusToSystem',
+                  actionId: '14200',
+                  isInitialValue: false,
+                  clickCount: '1',
+                },
+              ],
             },
           },
           options: {
@@ -4293,12 +5349,14 @@ describe('internal-plugin-metrics', () => {
           payload: {
             meetingSummaryInfo: {
               featureName: 'syncSystemVideoStatus',
-              featureActions: [{
-                actionName: 'syncMeetingVideoUnmuteStatusToSystem',
-                actionId: '13400',
-                isInitialValue: false,
-                clickCount: '1'
-              }]
+              featureActions: [
+                {
+                  actionName: 'syncMeetingVideoUnmuteStatusToSystem',
+                  actionId: '13400',
+                  isInitialValue: false,
+                  clickCount: '1',
+                },
+              ],
             },
           },
           options: {
@@ -4322,17 +5380,17 @@ describe('internal-plugin-metrics', () => {
 
       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 };
+        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 });
+        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);
 
@@ -4343,17 +5401,17 @@ describe('internal-plugin-metrics', () => {
         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));
+        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));
+        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 };
+        const options = {meetingId: fakeMeeting.id};
+        const payload = {mediaType: 'video' as const};
 
         // Set up some tracking data
         cd.submitClientEvent({
@@ -4381,8 +5439,8 @@ describe('internal-plugin-metrics', () => {
       });
 
       it('should handle non-existent correlationId gracefully', () => {
-        const options = { meetingId: fakeMeeting.id };
-        const payload = { mediaType: 'video' as const };
+        const options = {meetingId: fakeMeeting.id};
+        const payload = {mediaType: 'video' as const};
 
         // Set up some tracking data
         cd.submitClientEvent({
@@ -4403,10 +5461,10 @@ describe('internal-plugin-metrics', () => {
 
       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 } };
+        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({
@@ -4459,8 +5517,8 @@ describe('internal-plugin-metrics', () => {
 
       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 options = {meetingId: fakeMeeting.id};
+        const payload = {mediaType: 'video' as const};
         const submitToCallDiagnosticsStub = sinon.stub(cd, 'submitToCallDiagnostics');
 
         // Send first event (should succeed)