@webex/internal-plugin-metrics 3.4.0-next.1 → 3.4.0-next.2

package/dist/types/operational-metrics.d.ts

@@ -0,0 +1,19 @@
+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>}
+     */
+    submitOperationalEvent({ name, payload }: {
+        name: string;
+        payload: EventPayload;
+    }): void;
+}

package/package.json

@@ -26,22 +26,22 @@
     "@webex/eslint-config-legacy": "0.0.0",
     "@webex/jest-config-legacy": "0.0.0",
     "@webex/legacy-tools": "0.0.0",
-    "@webex/test-helper-chai": "3.4.0-next.1",
-    "@webex/test-helper-mocha": "3.4.0-next.1",
-    "@webex/test-helper-mock-webex": "3.4.0-next.1",
-    "@webex/test-helper-test-users": "3.4.0-next.1",
+    "@webex/test-helper-chai": "3.4.0-next.2",
+    "@webex/test-helper-mocha": "3.4.0-next.2",
+    "@webex/test-helper-mock-webex": "3.4.0-next.2",
+    "@webex/test-helper-test-users": "3.4.0-next.2",
     "eslint": "^8.24.0",
     "prettier": "^2.7.1",
     "sinon": "^9.2.4"
   },
   "dependencies": {
-    "@webex/common": "3.4.0-next.1",
-    "@webex/common-timers": "3.4.0-next.1",
+    "@webex/common": "3.4.0-next.2",
+    "@webex/common-timers": "3.4.0-next.2",
     "@webex/event-dictionary-ts": "^1.0.1406",
-    "@webex/internal-plugin-metrics": "3.4.0-next.1",
-    "@webex/test-helper-chai": "3.4.0-next.1",
-    "@webex/test-helper-mock-webex": "3.4.0-next.1",
-    "@webex/webex-core": "3.4.0-next.1",
+    "@webex/internal-plugin-metrics": "3.4.0-next.2",
+    "@webex/test-helper-chai": "3.4.0-next.2",
+    "@webex/test-helper-mock-webex": "3.4.0-next.2",
+    "@webex/webex-core": "3.4.0-next.2",
     "ip-anonymize": "^0.1.0",
     "lodash": "^4.17.21",
     "uuid": "^3.3.2"
@@ -54,5 +54,5 @@
     "test:style": "eslint ./src/**/*.*",
     "test:unit": "webex-legacy-tools test --unit --runner mocha"
   },
-  "version": "3.4.0-next.1"
+  "version": "3.4.0-next.2"
 }

package/src/behavioral-metrics.ts

@@ -0,0 +1,40 @@
+import {MetricEventProduct, MetricEventAgent, MetricEventVerb, EventPayload} from './metrics.types';
+import GenericMetrics from './generic-metrics';
+
+/**
+ * @description Util class to handle Behavioral Metrics
+ * @export
+ * @class BehavioralMetrics
+ */
+export default class BehavioralMetrics extends GenericMetrics {
+  /**
+   * Submit a behavioral metric to our metrics endpoint.
+   * @param {MetricEventProduct} product the product from which the metric is being submitted, e.g. 'webex' web client, 'wxcc_desktop'
+   * @param {MetricEventAgent} agent the source of the action for this metric
+   * @param {string} target the 'thing' that this metric includes information about
+   * @param {MetricEventVerb} verb the action that this metric includes information about
+   * @param {EventPayload} payload information specific to this event. This should be flat, i.e. it should not include nested objects.
+   * @returns {Promise<any>}
+   */
+  public submitBehavioralEvent({
+    product,
+    agent,
+    target,
+    verb,
+    payload,
+  }: {
+    product: MetricEventProduct;
+    agent: MetricEventAgent;
+    target: string;
+    verb: MetricEventVerb;
+    payload?: EventPayload;
+  }) {
+    const name = `${product}.${agent}.${target}.${verb}`;
+    const event = this.createTaggedEventObject({
+      type: ['behavioral'],
+      name,
+      payload,
+    });
+    this.submitEvent({kind: 'behavioral-events -> ', name, event});
+  }
+}

package/src/business-metrics.ts

@@ -0,0 +1,30 @@
+import GenericMetrics from './generic-metrics';
+import {EventPayload} from './metrics.types';
+
+/**
+ * @description Util class to handle Buisness Metrics
+ * @export
+ * @class BusinessMetrics
+ */
+export default class BusinessMetrics extends GenericMetrics {
+  /**
+   * Submit a buisness metric to our metrics endpoint.
+   * @param {string} name of the metric
+   * @param {EventPayload} user payload of the metric
+   * @returns {Promise<any>}
+   */
+  public submitBusinessEvent({name, payload}: {name: string; payload: EventPayload}) {
+    const event = {
+      type: ['business'],
+      eventPayload: {
+        metricName: name,
+        timestamp: Date.now(),
+        context: this.getContext(),
+        browserDetails: this.getBrowserDetails(),
+        value: payload,
+      },
+    };
+
+    this.submitEvent({kind: 'buisness-events -> ', name, event});
+  }
+}

package/src/generic-metrics.ts

@@ -0,0 +1,146 @@
+import {StatelessWebexPlugin} from '@webex/webex-core';
+import {BrowserDetection} from '@webex/common';
+import {merge} from 'lodash';
+import ClientMetricsBatcher from './client-metrics-batcher';
+import {getOSNameInternal} from './metrics';
+import {DeviceContext, TaggedEvent, EventPayload, MetricType} from './metrics.types';
+
+const {getOSVersion, getBrowserName, getBrowserVersion} = BrowserDetection();
+
+/**
+ * @description top-level abstract class to handle Metrics and common routines.
+ * @export
+ * @class GenericMetrics
+ */
+export default abstract class GenericMetrics extends StatelessWebexPlugin {
+  // @ts-ignore
+  private clientMetricsBatcher: ClientMetricsBatcher;
+  private logger: any; // to avoid adding @ts-ignore everywhere
+  private device: any;
+  private version: string;
+  private deviceId = '';
+
+  /**
+   * Constructor
+   * @param {any[]} args
+   */
+  constructor(...args) {
+    super(...args);
+    // @ts-ignore
+    this.logger = this.webex.logger;
+    // @ts-ignore
+    this.clientMetricsBatcher = new ClientMetricsBatcher({}, {parent: this.webex});
+    // @ts-ignore
+    this.device = this.webex.internal.device;
+    // @ts-ignore
+    this.version = this.webex.version;
+  }
+
+  /**
+   * Submit a buisness metric to our metrics endpoint.
+   * @param {string} kind of metric for logging
+   * @param {string} name of the metric
+   * @param {object} event
+   * @returns {Promise<any>}
+   */
+  protected submitEvent({kind, name, event}: {kind: string; name: string; event: object}) {
+    this.logger.log(kind, `@submitEvent. Submit event: ${name}`);
+
+    return this.clientMetricsBatcher.request(event);
+  }
+
+  /**
+   * Returns the deviceId from our registration with WDM.
+   * @returns {string} deviceId or empty string
+   */
+  protected getDeviceId(): string {
+    if (this.deviceId === '') {
+      const {url} = this.device;
+      if (url && url.length !== 0) {
+        const n = url.lastIndexOf('/');
+        if (n !== -1) {
+          this.deviceId = url.substring(n + 1);
+        }
+      }
+    }
+
+    return this.deviceId;
+  }
+
+  /**
+   * Returns the context object to be submitted with all metrics.
+   * @returns {DeviceContext}
+   */
+  protected getContext(): DeviceContext {
+    return {
+      app: {
+        version: this.version,
+      },
+      device: {
+        id: this.getDeviceId(),
+      },
+      locale: window.navigator.language,
+      os: {
+        name: getOSNameInternal(),
+        version: getOSVersion(),
+      },
+    };
+  }
+
+  /**
+   * Returns the browser details to be included with all metrics.
+   * @returns {object}
+   */
+  protected getBrowserDetails(): object {
+    return {
+      browser: getBrowserName(),
+      browserHeight: window.innerHeight,
+      browserVersion: getBrowserVersion(),
+      browserWidth: window.innerWidth,
+      domain: window.location.hostname,
+      inIframe: window.self !== window.top,
+      locale: window.navigator.language,
+      os: getOSNameInternal(),
+    };
+  }
+
+  /**
+   * Returns true once we have the deviceId we need to submit behavioral/operational/buisness events
+   * @returns {boolean}
+   */
+  public isReadyToSubmitEvents(): boolean {
+    const deviceId = this.getDeviceId();
+
+    return deviceId && deviceId.length !== 0;
+  }
+
+  /**
+   * Creates the object to send to our metrics endpoint for a tagged event (i.e. behavoral or operational)
+   * @param {[MetricType]} list of event type (i.e. ['behavioral'], ['operational', 'behavioral'])
+   * @param {string} metric name
+   * @param {EventPayload} user payload
+   * @returns {EventPayload}
+   */
+  protected createTaggedEventObject({
+    type,
+    name,
+    payload,
+  }: {
+    type: [MetricType];
+    name: string;
+    payload: EventPayload;
+  }): TaggedEvent {
+    let allTags: EventPayload = payload;
+    allTags = merge(allTags, this.getBrowserDetails());
+
+    const event = {
+      context: this.getContext(),
+      metricName: name,
+      tags: allTags,
+      timestamp: Date.now(),
+      type,
+    };
+
+    return event;
+  }
+}

package/src/index.ts

@@ -22,7 +22,9 @@ import * as CALL_DIAGNOSTIC_CONFIG from './call-diagnostic/config';
 import * as CallDiagnosticUtils from './call-diagnostic/call-diagnostic-metrics.util';
 import CallDiagnosticMetrics from './call-diagnostic/call-diagnostic-metrics';
 import CallDiagnosticLatencies from './call-diagnostic/call-diagnostic-metrics-latencies';
-import BehavioralMetrics from './behavioral/behavioral-metrics';
+import BehavioralMetrics from './behavioral-metrics';
+import OperationalMetrics from './operational-metrics';
+import BusinessMetrics from './business-metrics';
 
 registerInternalPlugin('metrics', Metrics, {
   config,
@@ -43,6 +45,8 @@ export {
   CallDiagnosticLatencies,
   CallDiagnosticMetrics,
   BehavioralMetrics,
+  OperationalMetrics,
+  BusinessMetrics,
 };
 export type {
   ClientEvent,

package/src/metrics.types.ts

@@ -102,7 +102,7 @@ export interface ClientEvent {
   options?: SubmitClientEventOptions;
 }
 
-export interface BehavioralEventContext {
+export interface DeviceContext {
   app: {version: string};
   device: {id: string};
   locale: string;
@@ -112,23 +112,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 +167,8 @@ export type MetricEventNames =
   | InternalEvent['name']
   | ClientEvent['name']
   | BehavioralEvent['metricName']
-  | OperationalEvent['name']
+  | OperationalEvent['metricName']
+  | BusinessEvent['eventPayload']['metricName']
   | FeatureEvent['name']
   | MediaQualityEvent['name'];
 
@@ -190,7 +204,7 @@ export type SubmitBehavioralEvent = (args: {
   agent: MetricEventAgent;
   target: string;
   verb: MetricEventVerb;
-  payload?: BehavioralEventPayload;
+  payload?: EventPayload;
 }) => void;
 
 export type SubmitClientEvent = (args: {
@@ -200,9 +214,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;
     });
   }
 
@@ -90,7 +94,21 @@ class Metrics extends WebexPlugin {
    * @returns true once we have the deviceId we need to submit behavioral events to Amplitude
    */
   isReadyToSubmitBehavioralEvents() {
-    return this.behavioralMetrics.isReadyToSubmitBehavioralEvents();
+    return this.behavioralMetrics?.isReadyToSubmitEvents() ?? false;
+  }
+
+  /**
+   * @returns true once we have the deviceId we need to submit operational events
+   */
+  isReadyToSubmitOperationalEvents() {
+    return this.operationalMetrics?.isReadyToSubmitEvents() ?? false;
+  }
+
+  /**
+   * @returns true once we have the deviceId we need to submit buisness events
+   */
+  isReadyToSubmitBusinessEvents() {
+    return this.businessMetrics?.isReadyToSubmitEvents() ?? false;
   }
 
   /**
@@ -108,9 +126,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 +137,11 @@ class Metrics extends WebexPlugin {
       return Promise.resolve();
     }
 
+    if (!this.behavioralMetrics) {
+      // @ts-ignore
+      this.behavioralMetrics = new BehavioralMetrics({}, {parent: this.webex});
+    }
+
     return this.behavioralMetrics.submitBehavioralEvent({product, agent, target, verb, payload});
   }
 
@@ -126,16 +149,44 @@ 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();
+    }
+
+    if (!this.operationalMetrics) {
+      // @ts-ignore
+      this.operationalMetrics = new OperationalMetrics({}, {parent: this.webex});
+    }
+
+    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();
+    }
+
+    if (!this.businessMetrics) {
+      // @ts-ignore
+      this.businessMetrics = new BusinessMetrics({}, {parent: this.webex});
+    }
+
+    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,
         });