@webex/internal-plugin-metrics 3.8.1-next.3 → 3.8.1-next.5

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

@@ -41,6 +41,9 @@ import {
   ClientSubServiceType,
   BrowserLaunchMethodType,
   DelayedClientEvent,
+  DelayedClientFeatureEvent,
+  FeatureEvent,
+  ClientFeatureEventPayload,
 } from '../metrics.types';
 import CallDiagnosticEventsBatcher from './call-diagnostic-metrics-batcher';
 import PreLoginMetricsBatcher from '../prelogin-metrics-batcher';
@@ -58,6 +61,8 @@ import {
   AUTHENTICATION_FAILED_CODE,
   WEBEX_SUB_SERVICE_TYPES,
   SDP_OFFER_CREATION_ERROR_MAP,
+  CALL_FEATURE_LOG_IDENTIFIER,
+  CALL_FEATURE_EVENT_FAILED_TO_SEND,
 } from './config';
 
 const {getOSVersion, getBrowserName, getBrowserVersion} = BrowserDetection();
@@ -97,6 +102,7 @@ export default class CallDiagnosticMetrics extends StatelessWebexPlugin {
   private hasLoggedBrowserSerial: boolean;
   private device: any;
   private delayedClientEvents: DelayedClientEvent[] = [];
+  private delayedClientFeatureEvents: DelayedClientFeatureEvent[] = [];
   private eventErrorCache: WeakMap<any, any> = new WeakMap();
   private isMercuryConnected = false;
 
@@ -427,12 +433,97 @@ export default class CallDiagnosticMetrics extends StatelessWebexPlugin {
   }
 
   /**
-   * TODO: NOT IMPLEMENTED
+   * Create feature event
+   * @param name
+   * @param payload
+   * @param options
+   * @returns
+   */
+  private prepareClientFeatureEvent({
+    name,
+    payload,
+    options,
+  }: {
+    name: FeatureEvent['name'];
+    payload?: ClientFeatureEventPayload;
+    options?: SubmitClientEventOptions;
+  }) {
+    const {meetingId, correlationId} = options;
+    let featureEventObject: FeatureEvent['payload'];
+
+    // events that will most likely happen in join phase
+    if (meetingId) {
+      featureEventObject = this.createFeatureEventObjectInMeeting({name, options});
+    } else {
+      throw new Error('Not implemented');
+    }
+
+    // merge any new properties, or override existing ones
+    featureEventObject = merge(featureEventObject, payload);
+
+    // append client event data to the call diagnostic event
+    const featureEvent = this.prepareDiagnosticEvent(featureEventObject, options);
+
+    return featureEvent;
+  }
+
+  /**
    * Submit Feature Event
+   * submit to business_ucf
    * @returns
    */
-  public submitFeatureEvent() {
-    throw Error('Not implemented');
+  public submitFeatureEvent({
+    name,
+    payload,
+    options,
+    delaySubmitEvent,
+  }: {
+    name: FeatureEvent['name'];
+    payload?: ClientFeatureEventPayload;
+    options?: SubmitClientEventOptions;
+    delaySubmitEvent?: boolean;
+  }) {
+    if (delaySubmitEvent) {
+      // Preserve the time when the event was triggered if delaying the submission to Call Features
+      const delayedOptions = {
+        ...options,
+        triggeredTime: new Date().toISOString(),
+      };
+
+      this.delayedClientFeatureEvents.push({
+        name,
+        payload,
+        options: delayedOptions,
+      });
+
+      return Promise.resolve();
+    }
+
+    this.logger.log(
+      CALL_FEATURE_LOG_IDENTIFIER,
+      'CallFeatureMetrics: @submitFeatureEvent. Submit Client Feature Event CA event.',
+      `name: ${name}`
+    );
+    const featureEvent = this.prepareClientFeatureEvent({name, payload, options});
+
+    this.validator({type: 'ce', event: featureEvent});
+
+    return this.submitToCallFeatures(featureEvent);
+  }
+
+  /**
+   * Submit Feature Event
+   * type is business
+   * @param event
+   */
+  submitToCallFeatures(event: Event): Promise<any> {
+    // build metrics-a event type
+    const finalEvent = {
+      eventPayload: event,
+      type: ['business'],
+    };
+
+    return this.callDiagnosticEventsBatcher.request(finalEvent);
   }
 
   /**
@@ -691,20 +782,20 @@ export default class CallDiagnosticMetrics extends StatelessWebexPlugin {
   }
 
   /**
-   * Create client event object for in meeting events
-   * @param arg - create args
-   * @param arg.event - event key
-   * @param arg.options - options
+   * Create common object for in meeting events
+   * @param name
+   * @param options
+   * @param eventType - 'client' | 'feature'
    * @returns object
    */
-  private createClientEventObjectInMeeting({
+  private createCommonEventObjectInMeeting({
     name,
     options,
-    errors,
+    eventType = 'client',
   }: {
-    name: ClientEvent['name'];
+    name: string;
     options?: SubmitClientEventOptions;
-    errors?: ClientEventPayloadError;
+    eventType?: 'client' | 'feature';
   }) {
     const {
       meetingId,
@@ -719,16 +810,21 @@ export default class CallDiagnosticMetrics extends StatelessWebexPlugin {
 
     if (!meeting) {
       console.warn(
-        'Attempt to send client event but no meeting was found...',
+        'Attempt to send common event but no meeting was found...',
         `name: ${name}, meetingId: ${meetingId}`
       );
       // @ts-ignore
-      this.webex.internal.metrics.submitClientMetrics(CALL_DIAGNOSTIC_EVENT_FAILED_TO_SEND, {
-        fields: {
-          meetingId,
-          name,
-        },
-      });
+      this.webex.internal.metrics.submitClientMetrics(
+        eventType === 'feature'
+          ? CALL_FEATURE_EVENT_FAILED_TO_SEND
+          : CALL_DIAGNOSTIC_EVENT_FAILED_TO_SEND,
+        {
+          fields: {
+            meetingId,
+            name,
+          },
+        }
+      );
 
       return undefined;
     }
@@ -742,15 +838,13 @@ export default class CallDiagnosticMetrics extends StatelessWebexPlugin {
       sessionCorrelationId,
     });
 
-    // create client event object
-    const clientEventObject: ClientEvent['payload'] = {
+    // create common event object structur
+    const commonEventObject = {
       name,
       canProceed: true,
       identifiers,
-      errors,
       eventData: {
         webClientDomain: window.location.hostname,
-        isMercuryConnected: this.isMercuryConnected,
       },
       userType: meeting.getCurUserType(),
       loginType:
@@ -769,18 +863,80 @@ export default class CallDiagnosticMetrics extends StatelessWebexPlugin {
 
     const joinFlowVersion = options.joinFlowVersion ?? meeting.callStateForMetrics?.joinFlowVersion;
     if (joinFlowVersion) {
-      clientEventObject.joinFlowVersion = joinFlowVersion;
+      // @ts-ignore
+      commonEventObject.joinFlowVersion = joinFlowVersion;
     }
     const meetingJoinedTime = meeting.isoLocalClientMeetingJoinTime;
     if (meetingJoinedTime) {
-      clientEventObject.meetingJoinedTime = meetingJoinedTime;
+      // @ts-ignore
+      commonEventObject.meetingJoinedTime = meetingJoinedTime;
     }
 
     if (options.meetingJoinPhase) {
-      clientEventObject.meetingJoinPhase = options.meetingJoinPhase;
+      // @ts-ignore
+      commonEventObject.meetingJoinPhase = options.meetingJoinPhase;
     }
 
-    return clientEventObject;
+    return commonEventObject;
+  }
+
+  /**
+   * Create client event object for in meeting events
+   * @param arg - create args
+   * @param arg.event - event key
+   * @param arg.options - options
+   * @returns object
+   */
+  private createClientEventObjectInMeeting({
+    name,
+    options,
+    errors,
+  }: {
+    name: ClientEvent['name'];
+    options?: SubmitClientEventOptions;
+    errors?: ClientEventPayloadError;
+  }) {
+    const commonObject = this.createCommonEventObjectInMeeting({
+      name,
+      options,
+      eventType: 'client',
+    });
+    if (!commonObject) return undefined;
+
+    return {
+      ...commonObject,
+      errors,
+      eventData: {
+        ...commonObject.eventData,
+        isMercuryConnected: this.isMercuryConnected,
+      },
+    } as ClientEvent['payload'];
+  }
+
+  /**
+   * Create feature event object for in meeting function event
+   * @param name
+   * @param options
+   * @returns object
+   */
+  private createFeatureEventObjectInMeeting({
+    name,
+    options,
+  }: {
+    name: FeatureEvent['name'];
+    options?: SubmitClientEventOptions;
+  }) {
+    const commonObject = this.createCommonEventObjectInMeeting({
+      name,
+      options,
+      eventType: 'feature',
+    });
+    if (!commonObject) return undefined;
+
+    return {
+      ...commonObject,
+      key: 'UcfFeatureUsage',
+    } as FeatureEvent['payload'];
   }
 
   /**
@@ -977,6 +1133,31 @@ export default class CallDiagnosticMetrics extends StatelessWebexPlugin {
     return Promise.all(promises);
   }
 
+  /**
+   * Submit Delayed feature Event CA events. Clears submitDelayedClientFeatureEvents array after submission.
+   */
+  public submitDelayedClientFeatureEvents(overrides?: Partial<DelayedClientEvent['options']>) {
+    this.logger.log(
+      CALL_FEATURE_LOG_IDENTIFIER,
+      'CallDiagnosticMetrics: @submitDelayedClientFeatureEvents. Submitting delayed feature events.'
+    );
+
+    if (this.delayedClientFeatureEvents.length === 0) {
+      return Promise.resolve();
+    }
+
+    const promises = this.delayedClientFeatureEvents.map((delayedSubmitClientEventParams) => {
+      const {name, payload, options} = delayedSubmitClientEventParams;
+      const optionsWithOverrides: DelayedClientEvent['options'] = {...options, ...overrides};
+
+      return this.submitFeatureEvent({name, payload, options: optionsWithOverrides});
+    });
+
+    this.delayedClientFeatureEvents = [];
+
+    return Promise.all(promises);
+  }
+
   /**
    * Prepare the event and send the request to metrics-a service.
    * @param event

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

@@ -257,6 +257,7 @@ export const prepareDiagnosticMetricItem = (webex: any, item: any) => {
   switch (eventName) {
     case 'client.webexapp.launched':
       joinTimes.downloadTime = cdl.getDownloadTimeJMT();
+      joinTimes.pageJmt = cdl.getPageJMT();
       break;
     case 'client.login.end':
       joinTimes.otherAppApiReqResp = cdl.getOtherAppApiReqResp();
@@ -267,6 +268,7 @@ export const prepareDiagnosticMetricItem = (webex: any, item: any) => {
       joinTimes.clickToInterstitial = cdl.getClickToInterstitial();
       joinTimes.refreshCaptchaServiceReqResp = cdl.getRefreshCaptchaReqResp();
       joinTimes.downloadIntelligenceModelsReqResp = cdl.getDownloadIntelligenceModelsReqResp();
+      joinTimes.clickToInterstitialWithUserDelay = cdl.getClickToInterstitialWithUserDelay();
       break;
 
     case 'client.call.initiated':
@@ -287,6 +289,8 @@ export const prepareDiagnosticMetricItem = (webex: any, item: any) => {
       joinTimes.totalJmt = cdl.getTotalJMT();
       joinTimes.clientJmt = cdl.getClientJMT();
       joinTimes.downloadTime = cdl.getDownloadTimeJMT();
+      joinTimes.clickToInterstitialWithUserDelay = cdl.getClickToInterstitialWithUserDelay();
+      joinTimes.totalJMTWithUserDelay = cdl.getTotalJMTWithUserDelay();
       break;
 
     case 'client.ice.end':
@@ -307,6 +311,8 @@ export const prepareDiagnosticMetricItem = (webex: any, item: any) => {
       joinTimes.interstitialToMediaOKJMT = cdl.getInterstitialToMediaOKJMT();
       joinTimes.callInitMediaEngineReady = cdl.getCallInitMediaEngineReady();
       joinTimes.stayLobbyTime = cdl.getStayLobbyTime();
+      joinTimes.totalMediaJMTWithUserDelay = cdl.getTotalMediaJMTWithUserDelay();
+      joinTimes.totalJMTWithUserDelay = cdl.getTotalJMTWithUserDelay();
       break;
 
     case 'client.media.tx.start':

package/src/call-diagnostic/config.ts

@@ -5,6 +5,7 @@
 import {ClientEventError, ClientSubServiceType} from '../metrics.types';
 
 export const CALL_DIAGNOSTIC_LOG_IDENTIFIER = 'call-diagnostic-events -> ';
+export const CALL_FEATURE_LOG_IDENTIFIER = 'call-diagnostic-events-feature -> ';
 
 export const AUTHENTICATION_FAILED_CODE = 1010;
 export const NETWORK_ERROR = 1026;
@@ -738,3 +739,5 @@ export const CLIENT_ERROR_CODE_TO_ERROR_PAYLOAD: Record<number, Partial<ClientEv
 };
 
 export const CALL_DIAGNOSTIC_EVENT_FAILED_TO_SEND = 'js_sdk_call_diagnostic_event_failed_to_send';
+
+export const CALL_FEATURE_EVENT_FAILED_TO_SEND = 'js_sdk_call_feature_event_failed_to_send';

package/src/metrics.types.ts

@@ -2,9 +2,12 @@ import {
   ClientEvent as RawClientEvent,
   Event as RawEvent,
   MediaQualityEvent as RawMediaQualityEvent,
+  FeatureEvent as RawFeatureEvent,
 } from '@webex/event-dictionary-ts';
 
-export type Event = Omit<RawEvent, 'event'> & {event: RawClientEvent | RawMediaQualityEvent};
+export type Event = Omit<RawEvent, 'event'> & {
+  event: RawClientEvent | RawMediaQualityEvent | RawFeatureEvent;
+};
 
 export type ClientEventError = NonNullable<RawClientEvent['errors']>[0];
 
@@ -212,10 +215,9 @@ export type BehavioralEvent = TaggedEvent;
 export type OperationalEvent = TaggedEvent;
 
 export interface FeatureEvent {
-  // TODO: not implemented
-  name: never;
-  payload?: never;
-  options?: never;
+  name: RawFeatureEvent['name'];
+  payload?: RawFeatureEvent;
+  options?: SubmitClientEventOptions;
 }
 
 export interface MediaQualityEvent {
@@ -251,6 +253,8 @@ export type ClientEventPayload = RecursivePartial<ClientEvent['payload']>;
 export type ClientEventLeaveReason = ClientEvent['payload']['leaveReason'];
 export type ClientEventPayloadError = ClientEvent['payload']['errors'];
 
+export type ClientFeatureEventPayload = RecursivePartial<FeatureEvent['payload']>;
+
 export type MediaQualityEventAudioSetupDelayPayload = NonNullable<
   MediaQualityEvent['payload']
 >['audioSetupDelay'];
@@ -311,6 +315,7 @@ export type PreComputedLatencies =
   | 'internal.download.time'
   | 'internal.get.cluster.time'
   | 'internal.click.to.interstitial'
+  | 'internal.click.to.interstitial.with.user.delay'
   | 'internal.refresh.captcha.time'
   | 'internal.exchange.ci.token.time'
   | 'internal.get.u2c.time'
@@ -339,3 +344,15 @@ export interface DelayedClientEvent {
   payload?: RecursivePartial<ClientEvent['payload']>;
   options?: SubmitClientEventOptions;
 }
+
+export type SubmitFeatureEvent = (args: {
+  name: FeatureEvent['name'];
+  payload?: RecursivePartial<FeatureEvent['payload']>;
+  options?: SubmitClientEventOptions;
+}) => Promise<any>;
+
+export interface DelayedClientFeatureEvent {
+  name: FeatureEvent['name'];
+  payload?: RecursivePartial<FeatureEvent['payload']>;
+  options?: SubmitClientEventOptions;
+}

package/src/new-metrics.ts

@@ -23,6 +23,7 @@ import {
   SubmitClientEventOptions,
   Table,
   DelayedClientEvent,
+  DelayedClientFeatureEvent,
 } from './metrics.types';
 import CallDiagnosticLatencies from './call-diagnostic/call-diagnostic-metrics-latencies';
 import {setMetricTimings} from './call-diagnostic/call-diagnostic-metrics.util';
@@ -51,11 +52,18 @@ class Metrics extends WebexPlugin {
    */
   delaySubmitClientEvents = false;
 
+  /**
+   * Whether or not to delay the submission of feature events.
+   */
+  delaySubmitClientFeatureEvents = false;
+
   /**
    * Overrides for delayed client events. E.g. if you want to override the correlationId for all delayed client events, you can set this to { correlationId: 'newCorrelationId' }
    */
   delayedClientEventsOverrides: Partial<DelayedClientEvent['options']> = {};
 
+  delayedClientFeatureEventsOverrides: Partial<DelayedClientFeatureEvent['options']> = {};
+
   /**
    * Constructor
    * @param args
@@ -275,7 +283,25 @@ class Metrics extends WebexPlugin {
     payload?: RecursivePartial<FeatureEvent['payload']>;
     options: any;
   }) {
-    throw new Error('Not implemented.');
+    if (!this.callDiagnosticLatencies || !this.callDiagnosticMetrics) {
+      // @ts-ignore
+      this.webex.logger.log(
+        `NewMetrics: @submitFeatureEvent. Attempted to submit before webex.ready. Event name: ${name}`
+      );
+
+      return Promise.resolve();
+    }
+    this.callDiagnosticLatencies.saveTimestamp({
+      key: name,
+      options: {meetingId: options?.meetingId},
+    });
+
+    return this.callDiagnosticMetrics.submitFeatureEvent({
+      name,
+      payload,
+      options,
+      delaySubmitEvent: this.delaySubmitClientFeatureEvents,
+    });
   }
 
   /**
@@ -432,6 +458,31 @@ class Metrics extends WebexPlugin {
 
     return Promise.resolve();
   }
+
+  /**
+   * Sets the value of setDelaySubmitClientFeatureEvents.
+   * If set to true, feature events will be delayed until submitDelayedClientFeatureEvents is called.
+   * If set to false, delayed feature events will be submitted.
+   *
+   * @param {object} options - {shouldDelay: A boolean value indicating whether to delay the submission of feature events,
+   * overrides: An object containing overrides for the feature events}
+   */
+  public setDelaySubmitClientFeatureEvents({
+    shouldDelay,
+    overrides,
+  }: {
+    shouldDelay: boolean;
+    overrides?: Partial<DelayedClientFeatureEvent['options']>;
+  }) {
+    this.delaySubmitClientFeatureEvents = shouldDelay;
+    this.delayedClientFeatureEventsOverrides = overrides || {};
+
+    if (this.isReady && !shouldDelay) {
+      return this.callDiagnosticMetrics.submitDelayedClientFeatureEvents(overrides);
+    }
+
+    return Promise.resolve();
+  }
 }
 
 export default Metrics;

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

@@ -108,6 +108,8 @@ describe('plugin-metrics', () => {
             .returns(10);
           webex.internal.newMetrics.callDiagnosticLatencies.getDownloadIntelligenceModelsReqResp =
             sinon.stub().returns(42);
+          webex.internal.newMetrics.callDiagnosticLatencies.getClickToInterstitialWithUserDelay =
+            sinon.stub().returns(12);
 
           const promise = webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
             //@ts-ignore
@@ -127,6 +129,7 @@ describe('plugin-metrics', () => {
               meetingInfoReqResp: 10,
               refreshCaptchaServiceReqResp: 10,
               downloadIntelligenceModelsReqResp: 42,
+              clickToInterstitialWithUserDelay: 12,
             },
           });
           assert.lengthOf(
@@ -183,9 +186,15 @@ describe('plugin-metrics', () => {
           webex.internal.newMetrics.callDiagnosticLatencies.getCallInitJoinReq = sinon
             .stub()
             .returns(10);
-            webex.internal.newMetrics.callDiagnosticLatencies.getDownloadTimeJMT = sinon
+          webex.internal.newMetrics.callDiagnosticLatencies.getDownloadTimeJMT = sinon
             .stub()
             .returns(100);
+          webex.internal.newMetrics.callDiagnosticLatencies.getClickToInterstitialWithUserDelay = sinon
+            .stub()
+            .returns(43);
+          webex.internal.newMetrics.callDiagnosticLatencies.getTotalJMTWithUserDelay = sinon
+            .stub()
+            .returns(64);
           const promise = webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
             //@ts-ignore
             {event: {name: 'client.locus.join.response'}}
@@ -209,6 +218,8 @@ describe('plugin-metrics', () => {
               totalJmt: 20,
               clientJmt: 5,
               downloadTime: 100,
+              clickToInterstitialWithUserDelay: 43,
+              totalJMTWithUserDelay: 64,
             },
           });
           assert.lengthOf(
@@ -338,6 +349,12 @@ describe('plugin-metrics', () => {
             webex.internal.newMetrics.callDiagnosticLatencies.getStayLobbyTime = sinon
             .stub()
             .returns(1);
+          webex.internal.newMetrics.callDiagnosticLatencies.getTotalMediaJMTWithUserDelay = sinon
+            .stub()
+            .returns(43);
+          webex.internal.newMetrics.callDiagnosticLatencies.getTotalJMTWithUserDelay = sinon
+            .stub()
+            .returns(64);
           const promise = webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
             //@ts-ignore
             {event: {name: 'client.media-engine.ready'}}
@@ -356,6 +373,8 @@ describe('plugin-metrics', () => {
               interstitialToMediaOKJMT: 22,
               callInitMediaEngineReady: 10,
               stayLobbyTime: 1,
+              totalMediaJMTWithUserDelay: 43,
+              totalJMTWithUserDelay: 64,
             },
           });
           assert.lengthOf(