@webex/internal-plugin-metrics 3.3.1-next.6 → 3.3.1-next.8

package/src/metrics.types.ts

@@ -20,6 +20,39 @@ export type BrowserLaunchMethodType = NonNullable<
   RawEvent['origin']['clientInfo']
 >['browserLaunchMethod'];
 
+export type MetricEventProduct = 'webex' | 'wxcc_desktop';
+
+export type MetricEventAgent = 'user' | 'browser' | 'system' | 'sdk' | 'redux' | 'service';
+
+export type MetricEventVerb =
+  | 'create'
+  | 'get'
+  | 'fetch'
+  | 'update'
+  | 'list'
+  | 'delete'
+  | 'select'
+  | 'view'
+  | 'set'
+  | 'toggle'
+  | 'load'
+  | 'reload'
+  | 'click'
+  | 'hover'
+  | 'register'
+  | 'unregister'
+  | 'enable'
+  | 'disable'
+  | 'use'
+  | 'complete'
+  | 'submit'
+  | 'apply'
+  | 'cancel'
+  | 'abort'
+  | 'sync'
+  | 'login'
+  | 'logout';
+
 export type SubmitClientEventOptions = {
   meetingId?: string;
   mediaConnections?: any[];
@@ -66,13 +99,26 @@ export interface ClientEvent {
   options?: SubmitClientEventOptions;
 }
 
+export interface BehavioralEventContext {
+  app: {version: string};
+  device: {id: string};
+  locale: string;
+  os: {
+    name: string;
+    version: string;
+  };
+}
+
 export interface BehavioralEvent {
-  // TODO: not implemented
-  name: 'host.meeting.participant.admitted' | 'sdk.media-flow.started';
-  payload?: never;
-  options?: never;
+  context: BehavioralEventContext;
+  metricName: string;
+  tags: Record<string, string | number | boolean>;
+  timestamp: number;
+  type: string[];
 }
 
+export type BehavioralEventPayload = BehavioralEvent['tags'];
+
 export interface OperationalEvent {
   // TODO: not implemented
   name: never;
@@ -104,7 +150,7 @@ export type RecursivePartial<T> = {
 export type MetricEventNames =
   | InternalEvent['name']
   | ClientEvent['name']
-  | BehavioralEvent['name']
+  | BehavioralEvent['metricName']
   | OperationalEvent['name']
   | FeatureEvent['name']
   | MediaQualityEvent['name'];
@@ -137,9 +183,11 @@ export type SubmitInternalEvent = (args: {
 }) => void;
 
 export type SubmitBehavioralEvent = (args: {
-  name: BehavioralEvent['name'];
-  payload?: RecursivePartial<BehavioralEvent['payload']>;
-  options?: any;
+  product: MetricEventProduct;
+  agent: MetricEventAgent;
+  target: string;
+  verb: MetricEventVerb;
+  payload?: BehavioralEventPayload;
 }) => void;
 
 export type SubmitClientEvent = (args: {

package/src/new-metrics.ts

@@ -6,11 +6,15 @@
 import {WebexPlugin} from '@webex/webex-core';
 
 import CallDiagnosticMetrics from './call-diagnostic/call-diagnostic-metrics';
+import BehavioralMetrics from './behavioral/behavioral-metrics';
 import {
   RecursivePartial,
+  MetricEventProduct,
+  MetricEventAgent,
+  MetricEventVerb,
   ClientEvent,
   FeatureEvent,
-  BehavioralEvent,
+  BehavioralEventPayload,
   OperationalEvent,
   MediaQualityEvent,
   InternalEvent,
@@ -32,6 +36,7 @@ class Metrics extends WebexPlugin {
   callDiagnosticLatencies: CallDiagnosticLatencies;
   // Helper classes to handle the different types of metrics
   callDiagnosticMetrics: CallDiagnosticMetrics;
+  behavioralMetrics: BehavioralMetrics;
 
   /**
    * Constructor
@@ -56,6 +61,8 @@ 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});
     });
   }
 
@@ -79,21 +86,40 @@ class Metrics extends WebexPlugin {
     }
   }
 
+  /**
+   * @returns true once we have the deviceId we need to submit behavioral events to Amplitude
+   */
+  isReadyToSubmitBehavioralEvents() {
+    return this.behavioralMetrics.isReadyToSubmitBehavioralEvents();
+  }
+
   /**
    * Behavioral event
    * @param args
    */
   submitBehavioralEvent({
-    name,
+    product,
+    agent,
+    target,
+    verb,
     payload,
-    options,
   }: {
-    name: BehavioralEvent['name'];
-    payload?: RecursivePartial<BehavioralEvent['payload']>;
-    options?: any;
+    product: MetricEventProduct;
+    agent: MetricEventAgent;
+    target: string;
+    verb: MetricEventVerb;
+    payload?: BehavioralEventPayload;
   }) {
-    this.callDiagnosticLatencies.saveTimestamp({key: name});
-    throw new Error('Not implemented.');
+    if (!this.behavioralMetrics) {
+      // @ts-ignore
+      this.webex.logger.log(
+        `NewMetrics: @submitBehavioralEvent. Attempted to submit before webex.ready: ${product}.${agent}.${target}.${verb}`
+      );
+
+      return Promise.resolve();
+    }
+
+    return this.behavioralMetrics.submitBehavioralEvent({product, agent, target, verb, payload});
   }
 
   /**

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

@@ -0,0 +1,164 @@
+import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
+import {BrowserDetection} from '@webex/common';
+import {BehavioralMetrics, config, getOSNameInternal} from '@webex/internal-plugin-metrics';
+import uuid from 'uuid';
+import {merge} from 'lodash';
+
+//@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('BehavioralMetrics', () => {
+    let webex;
+    let now;
+    let behavioralMetrics: BehavioralMetrics;
+
+    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());
+      behavioralMetrics = new BehavioralMetrics({}, {parent: webex});
+      sinon.stub(uuid, 'v4').returns('my-fake-id');
+    });
+
+    afterEach(() => {
+      sinon.restore();
+    });
+
+    describe('#getContext', () => {
+      it('should build context correctly', () => {
+        const res = behavioralMetrics.getContext();
+
+        assert.deepEqual(res, {
+          app: {
+            version: 'webex-version',
+          },
+          device: {
+            id: 'deviceId',
+          },
+          locale: 'language',
+          os: {
+            name: getOSNameInternal(),
+            version: getOSVersion(),
+          },
+        });
+      });
+    });
+
+    describe('#getDefaultTags', () => {
+      it('should build tags correctly', () => {
+        const res = behavioralMetrics.getDefaultTags();
+
+        assert.deepEqual(res, {
+          browser: getBrowserName(),
+          browserHeight: window.innerHeight,
+          browserVersion: getBrowserVersion(),
+          browserWidth: window.innerWidth,
+          domain: window.location.hostname,
+          inIframe: false,
+          locale: window.navigator.language,
+          os: getOSNameInternal(),
+        });
+      });
+    });
+
+    describe('#isReadyToSubmitBehavioralEvents', () => {
+      it('should return true when we have a deviceId, false when deviceId is empty or undefined', async () => {
+        assert.equal(true, behavioralMetrics.isReadyToSubmitBehavioralEvents());
+
+        webex.internal.device.url = "";
+        assert.equal(false, behavioralMetrics.isReadyToSubmitBehavioralEvents());
+
+        delete webex.internal.device.url;
+        assert.equal(false, behavioralMetrics.isReadyToSubmitBehavioralEvents());
+      });
+    });
+
+    describe('#createEventObject', () => {
+      it('should build event object correctly', async () => {
+        const res = behavioralMetrics.createEventObject({
+          product: 'webex',
+          agent: 'user',
+          target: 'target',
+          verb: 'create',
+          payload: tags,
+        });
+
+        assert.deepEqual(res, {
+          context: {
+            app: {
+              version: 'webex-version',
+            },
+            device: {
+              id: 'deviceId',
+            },
+            locale: 'language',
+            os: {
+              name: getOSNameInternal(),
+              version: getOSVersion(),
+            },
+          },
+          metricName: 'webex.user.target.create',
+          tags: merge(tags, {
+            browser: getBrowserName(),
+            browserVersion: getBrowserVersion(),
+            domain: window.location.hostname,
+            locale: window.navigator.language,
+            os: getOSNameInternal(),
+          }),
+          timestamp: res.timestamp,
+          type: ['behavioral'],
+        });
+      });
+    });
+  });
+});