@webex/internal-plugin-metrics 3.4.0 → 3.5.0

package/src/metrics.types.ts

@@ -61,6 +61,7 @@ export type SubmitClientEventOptions = {
   mediaConnections?: any[];
   rawError?: any;
   correlationId?: string;
+  sessionCorrelationId?: string;
   preLoginId?: string;
   environment?: EnvironmentType;
   newEnvironmentType?: NewEnvironmentType;
@@ -102,7 +103,7 @@ export interface ClientEvent {
   options?: SubmitClientEventOptions;
 }
 
-export interface BehavioralEventContext {
+export interface DeviceContext {
   app: {version: string};
   device: {id: string};
   locale: string;
@@ -112,23 +113,36 @@ export interface BehavioralEventContext {
   };
 }
 
-export interface BehavioralEvent {
-  context: BehavioralEventContext;
+export type MetricType = 'behavioral' | 'operational' | 'business';
+
+type InternalEventPayload = string | number | boolean;
+export type EventPayload = Record<string, InternalEventPayload>;
+export type BehavioralEventPayload = EventPayload; // for compatibilty, can be remove after wxcc-desktop did change their imports.
+
+export interface BusinessEventPayload {
   metricName: string;
-  tags: Record<string, string | number | boolean>;
   timestamp: number;
-  type: string[];
+  context: DeviceContext;
+  browserDetails: EventPayload;
+  value: EventPayload;
 }
 
-export type BehavioralEventPayload = BehavioralEvent['tags'];
+export interface BusinessEvent {
+  type: string[];
+  eventPayload: BusinessEventPayload;
+}
 
-export interface OperationalEvent {
-  // TODO: not implemented
-  name: never;
-  payload?: never;
-  options?: never;
+export interface TaggedEvent {
+  context: DeviceContext;
+  metricName: string;
+  tags: EventPayload;
+  timestamp: number;
+  type: [MetricType];
 }
 
+export type BehavioralEvent = TaggedEvent;
+export type OperationalEvent = TaggedEvent;
+
 export interface FeatureEvent {
   // TODO: not implemented
   name: never;
@@ -154,7 +168,8 @@ export type MetricEventNames =
   | InternalEvent['name']
   | ClientEvent['name']
   | BehavioralEvent['metricName']
-  | OperationalEvent['name']
+  | OperationalEvent['metricName']
+  | BusinessEvent['eventPayload']['metricName']
   | FeatureEvent['name']
   | MediaQualityEvent['name'];
 
@@ -190,7 +205,7 @@ export type SubmitBehavioralEvent = (args: {
   agent: MetricEventAgent;
   target: string;
   verb: MetricEventVerb;
-  payload?: BehavioralEventPayload;
+  payload?: EventPayload;
 }) => void;
 
 export type SubmitClientEvent = (args: {
@@ -200,9 +215,8 @@ export type SubmitClientEvent = (args: {
 }) => Promise<any>;
 
 export type SubmitOperationalEvent = (args: {
-  name: OperationalEvent['name'];
-  payload?: RecursivePartial<OperationalEvent['payload']>;
-  options?: any;
+  name: OperationalEvent['metricName'];
+  payload: EventPayload;
 }) => void;
 
 export type SubmitMQE = (args: {

package/src/new-metrics.ts

@@ -6,7 +6,9 @@
 import {WebexPlugin} from '@webex/webex-core';
 
 import CallDiagnosticMetrics from './call-diagnostic/call-diagnostic-metrics';
-import BehavioralMetrics from './behavioral/behavioral-metrics';
+import BehavioralMetrics from './behavioral-metrics';
+import OperationalMetrics from './operational-metrics';
+import BusinessMetrics from './business-metrics';
 import {
   RecursivePartial,
   MetricEventProduct,
@@ -14,7 +16,7 @@ import {
   MetricEventVerb,
   ClientEvent,
   FeatureEvent,
-  BehavioralEventPayload,
+  EventPayload,
   OperationalEvent,
   MediaQualityEvent,
   InternalEvent,
@@ -37,6 +39,9 @@ class Metrics extends WebexPlugin {
   // Helper classes to handle the different types of metrics
   callDiagnosticMetrics: CallDiagnosticMetrics;
   behavioralMetrics: BehavioralMetrics;
+  operationalMetrics: OperationalMetrics;
+  businessMetrics: BusinessMetrics;
+  isReady = false;
 
   /**
    * Constructor
@@ -61,8 +66,7 @@ class Metrics extends WebexPlugin {
     this.webex.once('ready', () => {
       // @ts-ignore
       this.callDiagnosticMetrics = new CallDiagnosticMetrics({}, {parent: this.webex});
-      // @ts-ignore
-      this.behavioralMetrics = new BehavioralMetrics({}, {parent: this.webex});
+      this.isReady = true;
     });
   }
 
@@ -86,11 +90,61 @@ class Metrics extends WebexPlugin {
     }
   }
 
+  /**
+   * if webex metrics is ready, build behavioral metric backend if not already done.
+   */
+  private lazyBuildBehavioralMetrics() {
+    if (this.isReady && !this.behavioralMetrics) {
+      // @ts-ignore
+      this.behavioralMetrics = new BehavioralMetrics({}, {parent: this.webex});
+    }
+  }
+
+  /**
+   * if webex metrics is ready, build operational metric backend if not already done.
+   */
+  private lazyBuildOperationalMetrics() {
+    if (this.isReady && !this.operationalMetrics) {
+      // @ts-ignore
+      this.operationalMetrics = new OperationalMetrics({}, {parent: this.webex});
+    }
+  }
+
+  /**
+   * if webex metrics is ready, build business metric backend if not already done.
+   */
+  private lazyBuildBusinessMetrics() {
+    if (this.isReady && !this.businessMetrics) {
+      // @ts-ignore
+      this.businessMetrics = new BusinessMetrics({}, {parent: this.webex});
+    }
+  }
+
   /**
    * @returns true once we have the deviceId we need to submit behavioral events to Amplitude
    */
   isReadyToSubmitBehavioralEvents() {
-    return this.behavioralMetrics.isReadyToSubmitBehavioralEvents();
+    this.lazyBuildBehavioralMetrics();
+
+    return this.behavioralMetrics?.isReadyToSubmitEvents() ?? false;
+  }
+
+  /**
+   * @returns true once we have the deviceId we need to submit operational events
+   */
+  isReadyToSubmitOperationalEvents() {
+    this.lazyBuildOperationalMetrics();
+
+    return this.operationalMetrics?.isReadyToSubmitEvents() ?? false;
+  }
+
+  /**
+   * @returns true once we have the deviceId we need to submit buisness events
+   */
+  isReadyToSubmitBusinessEvents() {
+    this.lazyBuildBusinessMetrics();
+
+    return this.businessMetrics?.isReadyToSubmitEvents() ?? false;
   }
 
   /**
@@ -108,9 +162,9 @@ class Metrics extends WebexPlugin {
     agent: MetricEventAgent;
     target: string;
     verb: MetricEventVerb;
-    payload?: BehavioralEventPayload;
+    payload?: EventPayload;
   }) {
-    if (!this.behavioralMetrics) {
+    if (!this.isReady) {
       // @ts-ignore
       this.webex.logger.log(
         `NewMetrics: @submitBehavioralEvent. Attempted to submit before webex.ready: ${product}.${agent}.${target}.${verb}`
@@ -119,6 +173,8 @@ class Metrics extends WebexPlugin {
       return Promise.resolve();
     }
 
+    this.lazyBuildBehavioralMetrics();
+
     return this.behavioralMetrics.submitBehavioralEvent({product, agent, target, verb, payload});
   }
 
@@ -126,16 +182,38 @@ class Metrics extends WebexPlugin {
    * Operational event
    * @param args
    */
-  submitOperationalEvent({
-    name,
-    payload,
-    options,
-  }: {
-    name: OperationalEvent['name'];
-    payload?: RecursivePartial<OperationalEvent['payload']>;
-    options?: any;
-  }) {
-    throw new Error('Not implemented.');
+  submitOperationalEvent({name, payload}: {name: string; payload?: EventPayload}) {
+    if (!this.isReady) {
+      // @ts-ignore
+      this.webex.logger.log(
+        `NewMetrics: @submitOperationalEvent. Attempted to submit before webex.ready: ${name}`
+      );
+
+      return Promise.resolve();
+    }
+
+    this.lazyBuildOperationalMetrics();
+
+    return this.operationalMetrics.submitOperationalEvent({name, payload});
+  }
+
+  /**
+   * Buisness event
+   * @param args
+   */
+  submitBusinessEvent({name, payload}: {name: string; payload: EventPayload}) {
+    if (!this.isReady) {
+      // @ts-ignore
+      this.webex.logger.log(
+        `NewMetrics: @submitBusinessEvent. Attempted to submit before webex.ready: ${name}`
+      );
+
+      return Promise.resolve();
+    }
+
+    this.lazyBuildBusinessMetrics();
+
+    return this.businessMetrics.submitBusinessEvent({name, payload});
   }
 
   /**

package/src/operational-metrics.ts

@@ -0,0 +1,24 @@
+import GenericMetrics from './generic-metrics';
+import {EventPayload} from './metrics.types';
+
+/**
+ * @description Util class to handle Operational Metrics
+ * @export
+ * @class OperationalMetrics
+ */
+export default class OperationalMetrics extends GenericMetrics {
+  /**
+   * Submit an operational metric to our metrics endpoint.
+   * @param {string} name of the metric
+   * @param {EventPayload} user payload of the metric
+   * @returns {Promise<any>}
+   */
+  public submitOperationalEvent({name, payload}: {name: string; payload: EventPayload}) {
+    const event = this.createTaggedEventObject({
+      type: ['operational'],
+      name,
+      payload,
+    });
+    this.submitEvent({kind: 'operational-events -> ', name, event});
+  }
+}

package/test/unit/spec/behavioral/behavioral-metrics.ts

@@ -74,6 +74,45 @@ describe('internal-plugin-metrics', () => {
       sinon.restore();
     });
 
+    describe('#sendEvent', () => {
+      it('should send correctly shaped behavioral event (check name building and internal tagged event building)', () => {
+        // For some reasons `jest` isn't available when testing form build server - so can't use `jest.fn()` here...
+        const requestCalls = [];
+        const request = function(arg) { requestCalls.push(arg) }
+
+        behavioralMetrics.clientMetricsBatcher.request = request;
+        
+        assert.equal(requestCalls.length, 0)
+        behavioralMetrics.submitBehavioralEvent({ product: "webex", agent: "user", target: "foo", verb: "get", payload: {bar:"gee"} })
+        assert.equal(requestCalls.length, 1)
+        assert.deepEqual(requestCalls[0], {
+          context: {
+            app: {version: 'webex-version'},
+            device: {id: 'deviceId'},
+            locale: 'language',
+            os: {
+              name: getOSNameInternal(),
+              version: getOSVersion(),
+            },
+          },
+          metricName: 'webex.user.foo.get',
+          tags: {
+            browser: getBrowserName(),
+            browserHeight: window.innerHeight,
+            browserVersion: getBrowserVersion(),
+            browserWidth: window.innerWidth,
+            domain: window.location.hostname,
+            inIframe: false,
+            locale: window.navigator.language,
+            os: getOSNameInternal(),
+            bar:"gee"
+          },
+          timestamp: requestCalls[0].timestamp, // This is to bypass time check, which is correctly tested below.
+          type: ['behavioral'],
+        });
+      })
+    })
+
     describe('#getContext', () => {
       it('should build context correctly', () => {
         const res = behavioralMetrics.getContext();
@@ -96,7 +135,7 @@ describe('internal-plugin-metrics', () => {
 
     describe('#getDefaultTags', () => {
       it('should build tags correctly', () => {
-        const res = behavioralMetrics.getDefaultTags();
+        const res = behavioralMetrics.getBrowserDetails();
 
         assert.deepEqual(res, {
           browser: getBrowserName(),
@@ -111,25 +150,27 @@ describe('internal-plugin-metrics', () => {
       });
     });
 
-    describe('#isReadyToSubmitBehavioralEvents', () => {
+    describe('#isReadyToSubmitEvents', () => {
       it('should return true when we have a deviceId, false when deviceId is empty or undefined', async () => {
-        assert.equal(true, behavioralMetrics.isReadyToSubmitBehavioralEvents());
+        let deviceIdUrl = webex.internal.device.url;
 
+        // testing case w/o device id url first, as the internal deviceId cache would bypass that flow.
         webex.internal.device.url = "";
-        assert.equal(false, behavioralMetrics.isReadyToSubmitBehavioralEvents());
+        assert.equal(false, behavioralMetrics.isReadyToSubmitEvents());
 
         delete webex.internal.device.url;
-        assert.equal(false, behavioralMetrics.isReadyToSubmitBehavioralEvents());
+        assert.equal(false, behavioralMetrics.isReadyToSubmitEvents());
+
+        webex.internal.device.url = deviceIdUrl;
+        assert.equal(true, behavioralMetrics.isReadyToSubmitEvents());
       });
     });
 
     describe('#createEventObject', () => {
       it('should build event object correctly', async () => {
-        const res = behavioralMetrics.createEventObject({
-          product: 'webex',
-          agent: 'user',
-          target: 'target',
-          verb: 'create',
+        const res = behavioralMetrics.createTaggedEventObject({
+          type:['behavioral'],
+          name:'webex.user.target.create',
           payload: tags,
         });
 

package/test/unit/spec/business/business-metrics.ts

@@ -0,0 +1,120 @@
+import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
+import {BrowserDetection} from '@webex/common';
+import {BusinessMetrics, config, getOSNameInternal} from '@webex/internal-plugin-metrics';
+import uuid from 'uuid';
+
+//@ts-ignore
+global.window = {location: {hostname: 'whatever'}, navigator: {language: 'language'}};
+process.env.NODE_ENV = 'test';
+
+const {getOSVersion, getBrowserName, getBrowserVersion} = BrowserDetection();
+
+describe('internal-plugin-metrics', () => {
+  describe('BusinessMetrics', () => {
+    let webex;
+    let now;
+    let businessMetrics: BusinessMetrics;
+
+    const tags = {key: 'val'};
+
+    beforeEach(() => {
+      now = new Date();
+
+      webex = {
+        canAuthorize: true,
+        version: 'webex-version',
+        internal: {
+          services: {
+            get: () => 'locus-url',
+          },
+          metrics: {
+            submitClientMetrics: sinon.stub(),
+            config: {...config.metrics},
+          },
+          newMetrics: {},
+          device: {
+            userId: 'userId',
+            url: 'https://wdm-intb.ciscospark.com/wdm/api/v1/devices/deviceId',
+            orgId: 'orgId',
+          },
+        },
+        meetings: {
+          config: {
+            metrics: {
+              clientType: 'TEAMS_CLIENT',
+              subClientType: 'WEB_APP',
+              clientName: 'Cantina',
+            },
+          },
+          geoHintInfo: {
+            clientAddress: '1.3.4.5',
+            countryCode: 'UK',
+          },
+        },
+        credentials: {
+          isUnverifiedGuest: false,
+        },
+        prepareFetchOptions: sinon.stub().callsFake((opts: any) => ({...opts, foo: 'bar'})),
+        request: sinon.stub().resolves({body: {}}),
+        logger: {
+          log: sinon.stub(),
+          error: sinon.stub(),
+        },
+      };
+
+      sinon.createSandbox();
+      sinon.useFakeTimers(now.getTime());
+      businessMetrics = new BusinessMetrics({}, {parent: webex});
+      sinon.stub(uuid, 'v4').returns('my-fake-id');
+    });
+
+    afterEach(() => {
+      sinon.restore();
+    });
+
+    describe('#sendEvent', () => {
+      it('should send correctly shaped business event (check name building and internal tagged event building)', () => {
+        // For some reasons `jest` isn't available when testing form build server - so can't use `jest.fn()` here...
+        const requestCalls = [];
+        const request = function(arg) { requestCalls.push(arg) }
+
+        businessMetrics.clientMetricsBatcher.request = request;
+        
+        assert.equal(requestCalls.length, 0)
+        businessMetrics.submitBusinessEvent({ name: "foobar", payload: {bar:"gee"} })
+        assert.equal(requestCalls.length, 1)
+        assert.deepEqual(requestCalls[0], {
+          eventPayload: {
+            context: {
+              app: {version: 'webex-version'},
+              device: {id: 'deviceId'},
+              locale: 'language',
+              os: {
+                name: getOSNameInternal(),
+                version: getOSVersion(),
+              },
+            },
+            key: 'foobar',
+            browserDetails: {
+              browser: getBrowserName(),
+              browserHeight: window.innerHeight,
+              browserVersion: getBrowserVersion(),
+              browserWidth: window.innerWidth,
+              domain: window.location.hostname,
+              inIframe: false,
+              locale: window.navigator.language,
+              os: getOSNameInternal(),
+            },
+            client_timestamp: requestCalls[0].eventPayload.client_timestamp, // This is to bypass time check, which is checked below.
+            value: {
+              bar: "gee"
+            }
+          },
+          type: ['business'],
+        });
+        assert.isNumber(requestCalls[0].eventPayload.client_timestamp)
+      })
+    })
+  });
+});

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

@@ -372,6 +372,7 @@ describe('internal-plugin-metrics', () => {
             {mediaAgentAlias: 'mediaAgentAlias', mediaAgentGroupId: 'mediaAgentGroupId'},
           ],
           webexConferenceIdStr: 'webexConferenceIdStr',
+          sessionCorrelationId: 'sessionCorrelationId',
           globalMeetingId: 'globalMeetingId',
           meeting: {
             ...fakeMeeting,
@@ -386,6 +387,7 @@ describe('internal-plugin-metrics', () => {
         assert.deepEqual(res, {
           correlationId: 'correlationId',
           webexConferenceIdStr: 'webexConferenceIdStr1',
+          sessionCorrelationId: 'sessionCorrelationId',
           globalMeetingId: 'globalMeetingId1',
           deviceId: 'deviceUrl',
           locusId: 'url',
@@ -608,6 +610,7 @@ describe('internal-plugin-metrics', () => {
           meeting: fakeMeeting,
           mediaConnections: [{mediaAgentAlias: 'alias', mediaAgentGroupId: '1'}],
           webexConferenceIdStr: undefined,
+          sessionCorrelationId: undefined,
           globalMeetingId: undefined,
         });
         assert.notCalled(generateClientEventErrorPayloadSpy);
@@ -762,7 +765,7 @@ describe('internal-plugin-metrics', () => {
         ]);
       });
 
-      it('should submit client event successfully with correlationId, webexConferenceIdStr and globalMeetingId', () => {
+      it('should submit client event successfully with correlationId, webexConferenceIdStr, sessionCorrelationId, and globalMeetingId', () => {
         const prepareDiagnosticEventSpy = sinon.spy(cd, 'prepareDiagnosticEvent');
         const submitToCallDiagnosticsSpy = sinon.spy(cd, 'submitToCallDiagnostics');
         const generateClientEventErrorPayloadSpy = sinon.spy(cd, 'generateClientEventErrorPayload');
@@ -773,6 +776,7 @@ describe('internal-plugin-metrics', () => {
           correlationId: 'correlationId',
           webexConferenceIdStr: 'webexConferenceIdStr1',
           globalMeetingId: 'globalMeetingId1',
+          sessionCorrelationId: 'sessionCorrelationId1'
         };
 
         cd.submitClientEvent({
@@ -784,6 +788,7 @@ describe('internal-plugin-metrics', () => {
           correlationId: 'correlationId',
           webexConferenceIdStr: 'webexConferenceIdStr1',
           globalMeetingId: 'globalMeetingId1',
+          sessionCorrelationId: 'sessionCorrelationId1',
           preLoginId: undefined,
         });
 
@@ -798,6 +803,7 @@ describe('internal-plugin-metrics', () => {
             identifiers: {
               correlationId: 'correlationId',
               webexConferenceIdStr: 'webexConferenceIdStr1',
+              sessionCorrelationId: 'sessionCorrelationId1',
               globalMeetingId: 'globalMeetingId1',
               deviceId: 'deviceUrl',
               locusUrl: 'locus-url',
@@ -818,6 +824,7 @@ describe('internal-plugin-metrics', () => {
             identifiers: {
               correlationId: 'correlationId',
               webexConferenceIdStr: 'webexConferenceIdStr1',
+              sessionCorrelationId: 'sessionCorrelationId1',
               globalMeetingId: 'globalMeetingId1',
               deviceId: 'deviceUrl',
               locusUrl: 'locus-url',
@@ -863,6 +870,7 @@ describe('internal-plugin-metrics', () => {
           webexConferenceIdStr: 'webexConferenceIdStr1',
           globalMeetingId: 'globalMeetingId1',
           preLoginId: 'myPreLoginId',
+          sessionCorrelationId: 'sessionCorrelationId1'
         };
 
         cd.submitClientEvent({
@@ -875,6 +883,7 @@ describe('internal-plugin-metrics', () => {
           webexConferenceIdStr: 'webexConferenceIdStr1',
           globalMeetingId: 'globalMeetingId1',
           preLoginId: 'myPreLoginId',
+          sessionCorrelationId: 'sessionCorrelationId1'
         });
 
         assert.notCalled(generateClientEventErrorPayloadSpy);
@@ -887,6 +896,7 @@ describe('internal-plugin-metrics', () => {
             },
             identifiers: {
               correlationId: 'correlationId',
+              sessionCorrelationId: 'sessionCorrelationId1',
               webexConferenceIdStr: 'webexConferenceIdStr1',
               globalMeetingId: 'globalMeetingId1',
               deviceId: 'deviceUrl',
@@ -913,6 +923,7 @@ describe('internal-plugin-metrics', () => {
               canProceed: true,
               identifiers: {
                 correlationId: 'correlationId',
+                sessionCorrelationId: 'sessionCorrelationId1',
                 userId: 'myPreLoginId',
                 deviceId: 'deviceUrl',
                 orgId: 'orgId',
@@ -1417,6 +1428,7 @@ describe('internal-plugin-metrics', () => {
           meetingId: fakeMeeting.id,
           webexConferenceIdStr: 'webexConferenceIdStr1',
           globalMeetingId: 'globalMeetingId1',
+          sessionCorrelationId: 'sessionCorrelationId1'
         };
 
         cd.submitMQE({

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

@@ -235,6 +235,8 @@ describe('internal-plugin-metrics', () => {
   });
 
   describe('getBuildType', () => {
+    const webex = {internal: {metrics: {config: {}}}};
+
     beforeEach(() => {
       process.env.NODE_ENV = 'production';
     });
@@ -246,18 +248,26 @@ describe('internal-plugin-metrics', () => {
       ['https://web.webex.com', true, 'test'],
     ].forEach(([webClientDomain, markAsTestEvent, expected]) => {
       it(`returns expected result for ${webClientDomain}`, () => {
-        assert.deepEqual(getBuildType(webClientDomain, markAsTestEvent as any), expected);
+        assert.deepEqual(getBuildType(webex, webClientDomain, markAsTestEvent as any), expected);
       });
     });
 
     it('returns "test" for NODE_ENV "foo"', () => {
       process.env.NODE_ENV = 'foo';
-      assert.deepEqual(getBuildType('production'), 'test');
+      assert.deepEqual(getBuildType(webex, 'production'), 'test');
     });
 
     it('returns "test" for NODE_ENV "production" and markAsTestEvent = true', () => {
       process.env.NODE_ENV = 'production';
-      assert.deepEqual(getBuildType('my.domain', true), 'test');
+      assert.deepEqual(getBuildType(webex, 'my.domain', true), 'test');
+    });
+
+    it('returns "test" for NODE_ENV "production" when webex.caBuildType = "test"', () => {
+      process.env.NODE_ENV = 'production';
+      assert.deepEqual(
+        getBuildType({internal: {metrics: {config: {caBuildType: 'test'}}}}, 'my.domain'),
+        'test'
+      );
     });
   });
 
@@ -418,8 +428,8 @@ describe('internal-plugin-metrics', () => {
             name: 'client.exit.app',
             eventData: {
               markAsTestEvent: true,
-              webClientDomain: 'https://web.webex.com'
-            }
+              webClientDomain: 'https://web.webex.com',
+            },
           },
         },
         type: ['diagnostic-event'],

package/test/unit/spec/new-metrics.ts

@@ -73,6 +73,20 @@ describe('internal-plugin-metrics', () => {
       sinon.restore();
     })
 
+    it('lazy metrics backend initialization when checking if backend ready', () => {
+      assert.isUndefined(webex.internal.newMetrics.behavioralMetrics);
+      webex.internal.newMetrics.isReadyToSubmitBehavioralEvents();
+      assert.isDefined(webex.internal.newMetrics.behavioralMetrics);
+
+      assert.isUndefined(webex.internal.newMetrics.operationalMetrics);
+      webex.internal.newMetrics.isReadyToSubmitOperationalEvents();
+      assert.isDefined(webex.internal.newMetrics.operationalMetrics);
+
+      assert.isUndefined(webex.internal.newMetrics.businessMetrics)
+      webex.internal.newMetrics.isReadyToSubmitBusinessEvents();
+      assert.isDefined(webex.internal.newMetrics.businessMetrics);
+    })
+  
     it('submits Client Event successfully', () => {
       webex.internal.newMetrics.submitClientEvent({
         name: 'client.alert.displayed',