@webex/internal-plugin-metrics 3.7.0 → 3.8.0-next.10

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

@@ -13,6 +13,9 @@ import {
 } from '@webex/internal-plugin-metrics';
 import uuid from 'uuid';
 import {omit} from 'lodash';
+import { glob } from 'glob';
+import { expect } from 'chai';
+import { ClientEmailInput, ClientUserNameInput } from '@webex/internal-plugin-metrics/src/metrics.types';
 
 //@ts-ignore
 global.window = {location: {hostname: 'whatever'}};
@@ -58,10 +61,26 @@ describe('internal-plugin-metrics', () => {
       sessionCorrelationId: 'sessionCorrelationId3',
     };
 
+    const fakeMeeting4 = {
+      ...fakeMeeting,
+      id: '4',
+      isoLocalClientMeetingJoinTime: 'testTimeString',
+    }
+    const fakeMeeting5 = {
+      ...fakeMeeting,
+      id: '5',
+      correlationId: 'correlationId5',
+      sessionCorrelationId: 'sessionCorrelationId5',
+      userNameInput: 'test',
+      emailInput: 'test@test.com'
+    };
+
     const fakeMeetings = {
       1: fakeMeeting,
       2: fakeMeeting2,
       3: fakeMeeting3,
+      4: fakeMeeting4,
+      5: fakeMeeting5,
     };
 
     let webex;
@@ -730,32 +749,352 @@ describe('internal-plugin-metrics', () => {
             webexConferenceIdStr: 'webexConferenceIdStr1',
             globalMeetingId: 'globalMeetingId1',
           },
-          name: 'client.alert.displayed',
-        },
-        eventId: 'my-fake-id',
-        origin: {
-          origin: 'fake-origin',
-        },
-        originTime: {
-          sent: 'not_defined_yet',
-          triggered: now.toISOString(),
-        },
-        senderCountryCode: 'UK',
-        version: 1,
+          name: 'client.alert.displayed',
+        },
+        eventId: 'my-fake-id',
+        origin: {
+          origin: 'fake-origin',
+        },
+        originTime: {
+          sent: 'not_defined_yet',
+          triggered: now.toISOString(),
+        },
+        senderCountryCode: 'UK',
+        version: 1,
+      });
+    });
+
+    it('should prepare diagnostic event successfully when triggeredTime is supplied in the options object', () => {
+      const options = {meetingId: fakeMeeting.id, triggeredTime: 'fake-triggered-time'};
+      const getOriginStub = sinon.stub(cd, 'getOrigin').returns({origin: 'fake-origin'});
+      const clearEmptyKeysRecursivelyStub = sinon.stub(
+        CallDiagnosticUtils,
+        'clearEmptyKeysRecursively'
+      );
+
+      const res = cd.prepareDiagnosticEvent(
+        {
+          canProceed: false,
+          identifiers: {
+            correlationId: 'id',
+            webexConferenceIdStr: 'webexConferenceIdStr1',
+            globalMeetingId: 'globalMeetingId1',
+          },
+          name: 'client.alert.displayed',
+        },
+        options
+      );
+
+      assert.calledWith(getOriginStub, options, options.meetingId);
+      assert.calledOnce(clearEmptyKeysRecursivelyStub);
+      assert.deepEqual(res, {
+        event: {
+          canProceed: false,
+          identifiers: {
+            correlationId: 'id',
+            webexConferenceIdStr: 'webexConferenceIdStr1',
+            globalMeetingId: 'globalMeetingId1',
+          },
+          name: 'client.alert.displayed',
+        },
+        eventId: 'my-fake-id',
+        origin: {
+          origin: 'fake-origin',
+        },
+        originTime: {
+          sent: 'not_defined_yet',
+          triggered: 'fake-triggered-time',
+        },
+        senderCountryCode: 'UK',
+        version: 1,
+      });
+    });
+
+    describe('#submitClientEvent', () => {
+      it('should submit client event successfully with meetingId', () => {
+        const prepareDiagnosticEventSpy = sinon.spy(cd, 'prepareDiagnosticEvent');
+        const submitToCallDiagnosticsSpy = sinon.spy(cd, 'submitToCallDiagnostics');
+        const generateClientEventErrorPayloadSpy = sinon.spy(cd, 'generateClientEventErrorPayload');
+        const getIdentifiersSpy = sinon.spy(cd, 'getIdentifiers');
+        const getSubServiceTypeSpy = sinon.spy(cd, 'getSubServiceType');
+        sinon.stub(cd, 'getOrigin').returns({origin: 'fake-origin'});
+        const validatorSpy = sinon.spy(cd, 'validator');
+        const options = {
+          meetingId: fakeMeeting.id,
+          mediaConnections: [{mediaAgentAlias: 'alias', mediaAgentGroupId: '1'}],
+        };
+
+        cd.submitClientEvent({
+          name: 'client.alert.displayed',
+          options,
+        });
+
+        assert.called(getIdentifiersSpy);
+        assert.calledWith(getIdentifiersSpy, {
+          meeting: fakeMeeting,
+          mediaConnections: [{mediaAgentAlias: 'alias', mediaAgentGroupId: '1'}],
+          webexConferenceIdStr: undefined,
+          sessionCorrelationId: undefined,
+          globalMeetingId: undefined,
+        });
+        assert.notCalled(generateClientEventErrorPayloadSpy);
+        assert.calledWith(
+          prepareDiagnosticEventSpy,
+          {
+            canProceed: true,
+            eventData: {
+              webClientDomain: 'whatever',
+            },
+            identifiers: {
+              correlationId: 'correlationId',
+              deviceId: 'deviceUrl',
+              locusId: 'url',
+              locusStartTime: 'lastActive',
+              locusUrl: 'locus/url',
+              mediaAgentAlias: 'alias',
+              mediaAgentGroupId: '1',
+              orgId: 'orgId',
+              userId: 'userId',
+            },
+            loginType: 'login-ci',
+            name: 'client.alert.displayed',
+            userType: 'host',
+            isConvergedArchitectureEnabled: undefined,
+            webexSubServiceType: undefined,
+            webClientPreload: undefined,
+          },
+          options
+        );
+        assert.calledWith(submitToCallDiagnosticsSpy, {
+          event: {
+            canProceed: true,
+            eventData: {
+              webClientDomain: 'whatever',
+            },
+            identifiers: {
+              correlationId: 'correlationId',
+              deviceId: 'deviceUrl',
+              locusId: 'url',
+              locusStartTime: 'lastActive',
+              locusUrl: 'locus/url',
+              mediaAgentAlias: 'alias',
+              mediaAgentGroupId: '1',
+              orgId: 'orgId',
+              userId: 'userId',
+            },
+            loginType: 'login-ci',
+            name: 'client.alert.displayed',
+            userType: 'host',
+            isConvergedArchitectureEnabled: undefined,
+            webexSubServiceType: undefined,
+            webClientPreload: undefined,
+          },
+          eventId: 'my-fake-id',
+          origin: {
+            origin: 'fake-origin',
+          },
+          originTime: {
+            sent: 'not_defined_yet',
+            triggered: now.toISOString(),
+          },
+          senderCountryCode: 'UK',
+          version: 1,
+        });
+        assert.calledWith(validatorSpy, {
+          type: 'ce',
+          event: {
+            event: {
+              canProceed: true,
+              eventData: {
+                webClientDomain: 'whatever',
+              },
+              identifiers: {
+                correlationId: 'correlationId',
+                deviceId: 'deviceUrl',
+                locusId: 'url',
+                locusStartTime: 'lastActive',
+                locusUrl: 'locus/url',
+                mediaAgentAlias: 'alias',
+                mediaAgentGroupId: '1',
+                orgId: 'orgId',
+                userId: 'userId',
+              },
+              loginType: 'login-ci',
+              name: 'client.alert.displayed',
+              userType: 'host',
+              isConvergedArchitectureEnabled: undefined,
+              webexSubServiceType: undefined,
+              webClientPreload: undefined,
+            },
+            eventId: 'my-fake-id',
+            origin: {
+              origin: 'fake-origin',
+            },
+            originTime: {
+              sent: 'not_defined_yet',
+              triggered: now.toISOString(),
+            },
+            senderCountryCode: 'UK',
+            version: 1,
+          },
+        });
+
+        const webexLoggerLogCalls = webex.logger.log.getCalls();
+        assert.deepEqual(webexLoggerLogCalls[1].args, [
+          'call-diagnostic-events -> ',
+          'CallDiagnosticMetrics: @submitClientEvent. Submit Client Event CA event.',
+          `name: client.alert.displayed`,
+        ]);
+      });
+
+      it('should submit client event successfully with meetingId which has a sessionCorrelationId', () => {
+        const prepareDiagnosticEventSpy = sinon.spy(cd, 'prepareDiagnosticEvent');
+        const submitToCallDiagnosticsSpy = sinon.spy(cd, 'submitToCallDiagnostics');
+        const generateClientEventErrorPayloadSpy = sinon.spy(cd, 'generateClientEventErrorPayload');
+        const getIdentifiersSpy = sinon.spy(cd, 'getIdentifiers');
+        const getSubServiceTypeSpy = sinon.spy(cd, 'getSubServiceType');
+        sinon.stub(cd, 'getOrigin').returns({origin: 'fake-origin'});
+        const validatorSpy = sinon.spy(cd, 'validator');
+        const options = {
+          meetingId: fakeMeeting3.id,
+          mediaConnections: [{mediaAgentAlias: 'alias', mediaAgentGroupId: '1'}],
+        };
+
+        cd.submitClientEvent({
+          name: 'client.alert.displayed',
+          options,
+        });
+
+        assert.called(getIdentifiersSpy);
+        assert.calledWith(getIdentifiersSpy, {
+          meeting: {...fakeMeeting3, sessionCorrelationId: 'sessionCorrelationId3'},
+          mediaConnections: [{mediaAgentAlias: 'alias', mediaAgentGroupId: '1'}],
+          webexConferenceIdStr: undefined,
+          globalMeetingId: undefined,
+          sessionCorrelationId: undefined,
+        });
+        assert.notCalled(generateClientEventErrorPayloadSpy);
+        assert.calledWith(
+          prepareDiagnosticEventSpy,
+          {
+            canProceed: true,
+            eventData: {
+              webClientDomain: 'whatever',
+            },
+            identifiers: {
+              correlationId: 'correlationId3',
+              sessionCorrelationId: 'sessionCorrelationId3',
+              deviceId: 'deviceUrl',
+              locusId: 'url',
+              locusStartTime: 'lastActive',
+              locusUrl: 'locus/url',
+              mediaAgentAlias: 'alias',
+              mediaAgentGroupId: '1',
+              orgId: 'orgId',
+              userId: 'userId',
+            },
+            loginType: 'login-ci',
+            name: 'client.alert.displayed',
+            userType: 'host',
+            isConvergedArchitectureEnabled: undefined,
+            webexSubServiceType: undefined,
+            webClientPreload: undefined,
+          },
+          options
+        );
+        assert.calledWith(submitToCallDiagnosticsSpy, {
+          event: {
+            canProceed: true,
+            eventData: {
+              webClientDomain: 'whatever',
+            },
+            identifiers: {
+              correlationId: 'correlationId3',
+              sessionCorrelationId: 'sessionCorrelationId3',
+              deviceId: 'deviceUrl',
+              locusId: 'url',
+              locusStartTime: 'lastActive',
+              locusUrl: 'locus/url',
+              mediaAgentAlias: 'alias',
+              mediaAgentGroupId: '1',
+              orgId: 'orgId',
+              userId: 'userId',
+            },
+            loginType: 'login-ci',
+            name: 'client.alert.displayed',
+            userType: 'host',
+            isConvergedArchitectureEnabled: undefined,
+            webexSubServiceType: undefined,
+            webClientPreload: undefined,
+          },
+          eventId: 'my-fake-id',
+          origin: {
+            origin: 'fake-origin',
+          },
+          originTime: {
+            sent: 'not_defined_yet',
+            triggered: now.toISOString(),
+          },
+          senderCountryCode: 'UK',
+          version: 1,
+        });
+        assert.calledWith(validatorSpy, {
+          type: 'ce',
+          event: {
+            event: {
+              canProceed: true,
+              eventData: {
+                webClientDomain: 'whatever',
+              },
+              identifiers: {
+                correlationId: 'correlationId3',
+                sessionCorrelationId: 'sessionCorrelationId3',
+                deviceId: 'deviceUrl',
+                locusId: 'url',
+                locusStartTime: 'lastActive',
+                locusUrl: 'locus/url',
+                mediaAgentAlias: 'alias',
+                mediaAgentGroupId: '1',
+                orgId: 'orgId',
+                userId: 'userId',
+              },
+              loginType: 'login-ci',
+              name: 'client.alert.displayed',
+              userType: 'host',
+              isConvergedArchitectureEnabled: undefined,
+              webexSubServiceType: undefined,
+              webClientPreload: undefined,
+            },
+            eventId: 'my-fake-id',
+            origin: {
+              origin: 'fake-origin',
+            },
+            originTime: {
+              sent: 'not_defined_yet',
+              triggered: now.toISOString(),
+            },
+            senderCountryCode: 'UK',
+            version: 1,
+          },
+        });
+
+        const webexLoggerLogCalls = webex.logger.log.getCalls();
+        assert.deepEqual(webexLoggerLogCalls[1].args, [
+          'call-diagnostic-events -> ',
+          'CallDiagnosticMetrics: @submitClientEvent. Submit Client Event CA event.',
+          `name: client.alert.displayed`,
+        ]);
       });
-    });
 
-    describe('#submitClientEvent', () => {
-      it('should submit client event successfully with meetingId', () => {
+      it('should submit client event successfully with meetingId which has a meetingJoinedTime', () => {
         const prepareDiagnosticEventSpy = sinon.spy(cd, 'prepareDiagnosticEvent');
         const submitToCallDiagnosticsSpy = sinon.spy(cd, 'submitToCallDiagnostics');
         const generateClientEventErrorPayloadSpy = sinon.spy(cd, 'generateClientEventErrorPayload');
         const getIdentifiersSpy = sinon.spy(cd, 'getIdentifiers');
-        const getSubServiceTypeSpy = sinon.spy(cd, 'getSubServiceType');
         sinon.stub(cd, 'getOrigin').returns({origin: 'fake-origin'});
         const validatorSpy = sinon.spy(cd, 'validator');
         const options = {
-          meetingId: fakeMeeting.id,
+          meetingId: fakeMeeting4.id,
           mediaConnections: [{mediaAgentAlias: 'alias', mediaAgentGroupId: '1'}],
         };
 
@@ -766,16 +1105,17 @@ describe('internal-plugin-metrics', () => {
 
         assert.called(getIdentifiersSpy);
         assert.calledWith(getIdentifiersSpy, {
-          meeting: fakeMeeting,
+          meeting: {...fakeMeeting4},
           mediaConnections: [{mediaAgentAlias: 'alias', mediaAgentGroupId: '1'}],
           webexConferenceIdStr: undefined,
-          sessionCorrelationId: undefined,
           globalMeetingId: undefined,
+          sessionCorrelationId: undefined,
         });
         assert.notCalled(generateClientEventErrorPayloadSpy);
         assert.calledWith(
           prepareDiagnosticEventSpy,
           {
+            meetingJoinedTime: fakeMeeting4.isoLocalClientMeetingJoinTime,
             canProceed: true,
             eventData: {
               webClientDomain: 'whatever',
@@ -792,6 +1132,7 @@ describe('internal-plugin-metrics', () => {
               userId: 'userId',
             },
             loginType: 'login-ci',
+            webClientPreload: undefined,
             name: 'client.alert.displayed',
             userType: 'host',
             isConvergedArchitectureEnabled: undefined,
@@ -801,6 +1142,7 @@ describe('internal-plugin-metrics', () => {
         );
         assert.calledWith(submitToCallDiagnosticsSpy, {
           event: {
+            meetingJoinedTime: fakeMeeting4.isoLocalClientMeetingJoinTime,
             canProceed: true,
             eventData: {
               webClientDomain: 'whatever',
@@ -817,6 +1159,7 @@ describe('internal-plugin-metrics', () => {
               userId: 'userId',
             },
             loginType: 'login-ci',
+            webClientPreload: undefined,
             name: 'client.alert.displayed',
             userType: 'host',
             isConvergedArchitectureEnabled: undefined,
@@ -837,6 +1180,7 @@ describe('internal-plugin-metrics', () => {
           type: 'ce',
           event: {
             event: {
+              meetingJoinedTime: fakeMeeting4.isoLocalClientMeetingJoinTime,
               canProceed: true,
               eventData: {
                 webClientDomain: 'whatever',
@@ -853,6 +1197,7 @@ describe('internal-plugin-metrics', () => {
                 userId: 'userId',
               },
               loginType: 'login-ci',
+              webClientPreload: undefined,
               name: 'client.alert.displayed',
               userType: 'host',
               isConvergedArchitectureEnabled: undefined,
@@ -879,16 +1224,15 @@ describe('internal-plugin-metrics', () => {
         ]);
       });
 
-      it('should submit client event successfully with meetingId which has a sessionCorrelationId', () => {
+      it('should submit client event successfully with meetingId which has emailInput and userNameInput', () => {
         const prepareDiagnosticEventSpy = sinon.spy(cd, 'prepareDiagnosticEvent');
         const submitToCallDiagnosticsSpy = sinon.spy(cd, 'submitToCallDiagnostics');
         const generateClientEventErrorPayloadSpy = sinon.spy(cd, 'generateClientEventErrorPayload');
         const getIdentifiersSpy = sinon.spy(cd, 'getIdentifiers');
-        const getSubServiceTypeSpy = sinon.spy(cd, 'getSubServiceType');
         sinon.stub(cd, 'getOrigin').returns({origin: 'fake-origin'});
         const validatorSpy = sinon.spy(cd, 'validator');
         const options = {
-          meetingId: fakeMeeting3.id,
+          meetingId: fakeMeeting5.id,
           mediaConnections: [{mediaAgentAlias: 'alias', mediaAgentGroupId: '1'}],
         };
 
@@ -899,7 +1243,7 @@ describe('internal-plugin-metrics', () => {
 
         assert.called(getIdentifiersSpy);
         assert.calledWith(getIdentifiersSpy, {
-          meeting: {...fakeMeeting3, sessionCorrelationId: 'sessionCorrelationId3'},
+          meeting: {...fakeMeeting5, sessionCorrelationId: 'sessionCorrelationId5'},
           mediaConnections: [{mediaAgentAlias: 'alias', mediaAgentGroupId: '1'}],
           webexConferenceIdStr: undefined,
           globalMeetingId: undefined,
@@ -914,8 +1258,8 @@ describe('internal-plugin-metrics', () => {
               webClientDomain: 'whatever',
             },
             identifiers: {
-              correlationId: 'correlationId3',
-              sessionCorrelationId: 'sessionCorrelationId3',
+              correlationId: 'correlationId5',
+              sessionCorrelationId: 'sessionCorrelationId5',
               deviceId: 'deviceUrl',
               locusId: 'url',
               locusStartTime: 'lastActive',
@@ -928,8 +1272,11 @@ describe('internal-plugin-metrics', () => {
             loginType: 'login-ci',
             name: 'client.alert.displayed',
             userType: 'host',
+            userNameInput: 'test',
+            emailInput: 'test@test.com',
             isConvergedArchitectureEnabled: undefined,
             webexSubServiceType: undefined,
+            webClientPreload: undefined,
           },
           options
         );
@@ -940,8 +1287,8 @@ describe('internal-plugin-metrics', () => {
               webClientDomain: 'whatever',
             },
             identifiers: {
-              correlationId: 'correlationId3',
-              sessionCorrelationId: 'sessionCorrelationId3',
+              correlationId: 'correlationId5',
+              sessionCorrelationId: 'sessionCorrelationId5',
               deviceId: 'deviceUrl',
               locusId: 'url',
               locusStartTime: 'lastActive',
@@ -954,8 +1301,11 @@ describe('internal-plugin-metrics', () => {
             loginType: 'login-ci',
             name: 'client.alert.displayed',
             userType: 'host',
+            userNameInput: 'test',
+            emailInput: 'test@test.com',
             isConvergedArchitectureEnabled: undefined,
             webexSubServiceType: undefined,
+            webClientPreload: undefined,
           },
           eventId: 'my-fake-id',
           origin: {
@@ -977,8 +1327,8 @@ describe('internal-plugin-metrics', () => {
                 webClientDomain: 'whatever',
               },
               identifiers: {
-                correlationId: 'correlationId3',
-                sessionCorrelationId: 'sessionCorrelationId3',
+                correlationId: 'correlationId5',
+                sessionCorrelationId: 'sessionCorrelationId5',
                 deviceId: 'deviceUrl',
                 locusId: 'url',
                 locusStartTime: 'lastActive',
@@ -991,8 +1341,11 @@ describe('internal-plugin-metrics', () => {
               loginType: 'login-ci',
               name: 'client.alert.displayed',
               userType: 'host',
+              userNameInput: 'test',
+              emailInput: 'test@test.com',
               isConvergedArchitectureEnabled: undefined,
               webexSubServiceType: undefined,
+              webClientPreload: undefined,
             },
             eventId: 'my-fake-id',
             origin: {
@@ -1110,6 +1463,7 @@ describe('internal-plugin-metrics', () => {
             },
             loginType: 'login-ci',
             name: 'client.alert.displayed',
+            webClientPreload: undefined
           },
           options
         );
@@ -1131,6 +1485,7 @@ describe('internal-plugin-metrics', () => {
             },
             loginType: 'login-ci',
             name: 'client.alert.displayed',
+            webClientPreload: undefined
           },
           eventId: 'my-fake-id',
           origin: {
@@ -1204,6 +1559,97 @@ describe('internal-plugin-metrics', () => {
             },
             loginType: 'login-ci',
             name: 'client.alert.displayed',
+            webClientPreload: undefined,
+          },
+          options
+        );
+        assert.notCalled(submitToCallDiagnosticsSpy);
+        assert.calledWith(
+          submitToCallDiagnosticsPreLoginSpy,
+          {
+            eventId: 'my-fake-id',
+            version: 1,
+            origin: {origin: 'fake-origin'},
+            originTime: {triggered: now.toISOString(), sent: 'not_defined_yet'},
+            senderCountryCode: 'UK',
+            event: {
+              name: 'client.alert.displayed',
+              canProceed: true,
+              identifiers: {
+                correlationId: 'correlationId',
+                sessionCorrelationId: 'sessionCorrelationId1',
+                userId: 'myPreLoginId',
+                deviceId: 'deviceUrl',
+                orgId: 'orgId',
+                locusUrl: 'locus-url',
+                webexConferenceIdStr: 'webexConferenceIdStr1',
+                globalMeetingId: 'globalMeetingId1',
+              },
+              eventData: {webClientDomain: 'whatever'},
+              loginType: 'login-ci',
+              webClientPreload: undefined,
+            },
+          },
+          options.preLoginId
+        );
+      });
+
+      it('should submit client event successfully with emailInput and userNameInput as options', () => {
+        cd.device.userId = undefined;
+
+        const prepareDiagnosticEventSpy = sinon.spy(cd, 'prepareDiagnosticEvent');
+        const submitToCallDiagnosticsPreLoginSpy = sinon.spy(cd, 'submitToCallDiagnosticsPreLogin');
+        const submitToCallDiagnosticsSpy = sinon.spy(cd, 'submitToCallDiagnostics');
+        const generateClientEventErrorPayloadSpy = sinon.spy(cd, 'generateClientEventErrorPayload');
+        const getIdentifiersSpy = sinon.spy(cd, 'getIdentifiers');
+        sinon.stub(cd, 'getOrigin').returns({origin: 'fake-origin'});
+
+        const options = {
+          correlationId: 'correlationId',
+          webexConferenceIdStr: 'webexConferenceIdStr1',
+          globalMeetingId: 'globalMeetingId1',
+          preLoginId: 'myPreLoginId',
+          sessionCorrelationId: 'sessionCorrelationId1',
+          userNameInput: 'current' as ClientUserNameInput,
+          emailInput: 'current' as ClientEmailInput,
+        };
+
+        cd.submitClientEvent({
+          name: 'client.alert.displayed',
+          options,
+        });
+
+        assert.calledWith(getIdentifiersSpy, {
+          correlationId: 'correlationId',
+          webexConferenceIdStr: 'webexConferenceIdStr1',
+          globalMeetingId: 'globalMeetingId1',
+          preLoginId: 'myPreLoginId',
+          sessionCorrelationId: 'sessionCorrelationId1',
+        });
+
+        assert.notCalled(generateClientEventErrorPayloadSpy);
+        assert.calledWith(
+          prepareDiagnosticEventSpy,
+          {
+            canProceed: true,
+            eventData: {
+              webClientDomain: 'whatever',
+            },
+            identifiers: {
+              correlationId: 'correlationId',
+              sessionCorrelationId: 'sessionCorrelationId1',
+              webexConferenceIdStr: 'webexConferenceIdStr1',
+              globalMeetingId: 'globalMeetingId1',
+              deviceId: 'deviceUrl',
+              locusUrl: 'locus-url',
+              orgId: 'orgId',
+              userId: 'myPreLoginId',
+            },
+            userNameInput: 'current',
+            emailInput: 'current',
+            loginType: 'login-ci',
+            name: 'client.alert.displayed',
+            webClientPreload: undefined,
           },
           options
         );
@@ -1231,6 +1677,9 @@ describe('internal-plugin-metrics', () => {
               },
               eventData: {webClientDomain: 'whatever'},
               loginType: 'login-ci',
+              userNameInput: 'current',
+              emailInput: 'current',
+              webClientPreload: undefined,
             },
           },
           options.preLoginId
@@ -1273,6 +1722,7 @@ describe('internal-plugin-metrics', () => {
             joinFlowVersion: 'Other',
             isConvergedArchitectureEnabled: undefined,
             webexSubServiceType: undefined,
+            webClientPreload: undefined,
           },
           eventId: 'my-fake-id',
           origin: {
@@ -1325,6 +1775,84 @@ describe('internal-plugin-metrics', () => {
             joinFlowVersion: 'Other',
             isConvergedArchitectureEnabled: undefined,
             webexSubServiceType: undefined,
+            webClientPreload: 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 successfully with webClientPreload', () => {
+        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.config.metrics.webClientPreload = true;
+
+        const options = {
+          correlationId: 'correlationId',
+          webexConferenceIdStr: 'webexConferenceIdStr1',
+          globalMeetingId: 'globalMeetingId1',
+          sessionCorrelationId: 'sessionCorrelationId1',
+        };
+
+        cd.submitClientEvent({
+          name: 'client.alert.displayed',
+          options,
+        });
+
+        assert.notCalled(generateClientEventErrorPayloadSpy);
+        assert.calledWith(
+          prepareDiagnosticEventSpy,
+          {
+            canProceed: true,
+            eventData: {
+              webClientDomain: 'whatever',
+            },
+            identifiers: {
+              correlationId: 'correlationId',
+              webexConferenceIdStr: 'webexConferenceIdStr1',
+              sessionCorrelationId: 'sessionCorrelationId1',
+              globalMeetingId: 'globalMeetingId1',
+              deviceId: 'deviceUrl',
+              locusUrl: 'locus-url',
+              orgId: 'orgId',
+              userId: 'userId',
+            },
+            loginType: 'login-ci',
+            name: 'client.alert.displayed',
+            webClientPreload: true,
+          },
+          options
+        );
+        assert.calledWith(submitToCallDiagnosticsSpy, {
+          event: {
+            canProceed: true,
+            eventData: {
+              webClientDomain: 'whatever',
+            },
+            identifiers: {
+              correlationId: 'correlationId',
+              webexConferenceIdStr: 'webexConferenceIdStr1',
+              sessionCorrelationId: 'sessionCorrelationId1',
+              globalMeetingId: 'globalMeetingId1',
+              deviceId: 'deviceUrl',
+              locusUrl: 'locus-url',
+              orgId: 'orgId',
+              userId: 'userId',
+            },
+            loginType: 'login-ci',
+            name: 'client.alert.displayed',
+            webClientPreload: true,
           },
           eventId: 'my-fake-id',
           origin: {
@@ -1396,6 +1924,7 @@ describe('internal-plugin-metrics', () => {
             userType: 'host',
             isConvergedArchitectureEnabled: undefined,
             webexSubServiceType: undefined,
+            webClientPreload: undefined,
           },
           eventId: 'my-fake-id',
           origin: {
@@ -1475,6 +2004,7 @@ describe('internal-plugin-metrics', () => {
             userType: 'host',
             isConvergedArchitectureEnabled: undefined,
             webexSubServiceType: undefined,
+            webClientPreload: undefined,
           },
           eventId: 'my-fake-id',
           origin: {
@@ -1546,6 +2076,7 @@ describe('internal-plugin-metrics', () => {
             ],
             loginType: 'login-ci',
             name: 'client.alert.displayed',
+            webClientPreload: undefined,
           },
           eventId: 'my-fake-id',
           origin: {
@@ -1619,6 +2150,7 @@ describe('internal-plugin-metrics', () => {
             ],
             loginType: 'login-ci',
             name: 'client.alert.displayed',
+            webClientPreload: undefined,
           },
           eventId: 'my-fake-id',
           origin: {
@@ -1701,6 +2233,7 @@ describe('internal-plugin-metrics', () => {
             userType: 'host',
             isConvergedArchitectureEnabled: undefined,
             webexSubServiceType: undefined,
+            webClientPreload: undefined,
           },
           eventId: 'my-fake-id',
           origin: {
@@ -2621,15 +3154,36 @@ describe('internal-plugin-metrics', () => {
         assert.deepEqual(cd.getSubServiceType(fakeMeeting), 'ScheduledMeeting');
       });
 
-      it('returns subServicetype as Webinar when meeting is Webinar', () => {
+      it('returns subServicetype as Webinar when meeting is non-converged Webinar', () => {
         fakeMeeting.meetingInfo = {
           webexScheduled: true,
           pmr: false,
           enableEvent: true,
+          enableConvergedArchitecture: false,
+        };
+        assert.deepEqual(cd.getSubServiceType(fakeMeeting), 'Webinar');
+      });
+
+      it('returns subServicetype as Webinar when meeting is converged Webinar', () => {
+        fakeMeeting.meetingInfo = {
+          enableEvent: true,
+          isConvergedWebinar: true,
+          isConvergedWebinarWebcast: false,
+          enableConvergedArchitecture: true,
         };
         assert.deepEqual(cd.getSubServiceType(fakeMeeting), 'Webinar');
       });
 
+      it('returns subServicetype as Webcast when meeting is converged Webinar and enable webcast', () => {
+        fakeMeeting.meetingInfo = {
+          enableEvent: true,
+          isConvergedWebinar: false,
+          isConvergedWebinarWebcast: true,
+          enableConvergedArchitecture: true,
+        };
+        assert.deepEqual(cd.getSubServiceType(fakeMeeting), 'Webcast');
+      });
+
       it('returns subServicetype as undefined when correct parameters are not found', () => {
         fakeMeeting.meetingInfo = {};
         assert.deepEqual(cd.getSubServiceType(fakeMeeting), undefined);
@@ -2693,6 +3247,7 @@ describe('internal-plugin-metrics', () => {
                     userType: 'host',
                     isConvergedArchitectureEnabled: undefined,
                     webexSubServiceType: undefined,
+                    webClientPreload: undefined,
                   },
                   eventId: 'my-fake-id',
                   origin: {
@@ -2759,11 +3314,12 @@ describe('internal-plugin-metrics', () => {
         });
       });
 
-      it('includes expected joinFlowVersion from options when in-meeting', async () => {
+      it('includes expected joinFlowVersion and meetingJoinPhase from options when in-meeting', async () => {
         // meetingId means in-meeting
         const options = {
           meetingId: fakeMeeting.id,
           joinFlowVersion: 'NewFTE',
+          meetingJoinPhase: 'join',
         };
 
         const triggered = new Date();
@@ -2777,6 +3333,11 @@ describe('internal-plugin-metrics', () => {
           fetchOptions.body.metrics[0].eventPayload.event.joinFlowVersion,
           options.joinFlowVersion
         );
+
+        assert.equal(
+          fetchOptions.body.metrics[0].eventPayload.event.meetingJoinPhase,
+          options.meetingJoinPhase
+        );
       });
 
       it('includes expected joinFlowVersion from meeting callStateForMetrics when in-meeting', async () => {
@@ -2815,12 +3376,13 @@ describe('internal-plugin-metrics', () => {
         );
       });
 
-      it('includes expected joinFlowVersion from options during prejoin', async () => {
+      it('includes expected joinFlowVersion and meetingJoinPhase from options during prejoin', async () => {
         // correlationId and no meeting id means prejoin
         const options = {
           correlationId: 'myCorrelationId',
           preLoginId: 'myPreLoginId',
           joinFlowVersion: 'NewFTE',
+          meetingJoinPhase: 'pre-join',
         };
 
         const triggered = new Date();
@@ -2834,6 +3396,11 @@ describe('internal-plugin-metrics', () => {
           fetchOptions.body.metrics[0].eventPayload.event.joinFlowVersion,
           options.joinFlowVersion
         );
+
+        assert.equal(
+          fetchOptions.body.metrics[0].eventPayload.event.meetingJoinPhase,
+          options.meetingJoinPhase
+        );
       });
     });
 
@@ -2880,5 +3447,80 @@ describe('internal-plugin-metrics', () => {
         assert.deepEqual(cd.device, device);
       });
     });
+
+    describe('#submitDelayedClientEvents', () => {
+      it('does not call submitClientEvent if there were no delayed events', () => {
+        const submitClientEventSpy = sinon.spy(cd, 'submitClientEvent');
+
+        cd.submitDelayedClientEvents();
+
+        assert.notCalled(submitClientEventSpy);
+      });
+
+      it('calls submitClientEvent for every delayed event and clears delayedClientEvents array', () => {
+        const submitClientEventSpy = sinon.spy(cd, 'submitClientEvent');
+        const submitToCallDiagnosticsSpy = sinon.spy(cd, 'submitToCallDiagnostics');
+
+        const options = {
+          correlationId: 'correlationId',
+        };
+
+        cd.submitClientEvent({
+          name: 'client.alert.displayed',
+          options,
+          delaySubmitEvent: true,
+        });
+
+        cd.submitClientEvent({
+          name: 'client.alert.removed',
+          options,
+          delaySubmitEvent: true,
+        });
+
+        cd.submitClientEvent({
+          name: 'client.call.aborted',
+          options,
+          delaySubmitEvent: true,
+        });
+
+        assert.notCalled(submitToCallDiagnosticsSpy);
+        assert.calledThrice(submitClientEventSpy);
+        submitClientEventSpy.resetHistory();
+
+        cd.submitDelayedClientEvents();
+
+        assert.calledThrice(submitClientEventSpy);
+        assert.calledWith(submitClientEventSpy.firstCall, {
+          name: 'client.alert.displayed',
+          payload: undefined,
+          options: {
+            correlationId: 'correlationId',
+            triggeredTime: now.toISOString(),
+          },
+        });
+        assert.calledWith(submitClientEventSpy.secondCall, {
+          name: 'client.alert.removed',
+          payload: undefined,
+          options: {
+            correlationId: 'correlationId',
+            triggeredTime: now.toISOString(),
+          },
+        });
+        assert.calledWith(submitClientEventSpy.thirdCall, {
+          name: 'client.call.aborted',
+          payload: undefined,
+          options: {
+            correlationId: 'correlationId',
+            triggeredTime: now.toISOString(),
+          },
+        });
+        submitClientEventSpy.resetHistory();
+
+        cd.submitDelayedClientEvents();
+
+        // should not call submitClientEvent again if delayedClientEvents was cleared
+        assert.notCalled(submitClientEventSpy);
+      });
+    });
   });
 });