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

package/src/call-diagnostic/config.ts

@@ -16,6 +16,7 @@ export const MISSING_ROAP_ANSWER_CLIENT_CODE = 2007;
 export const DTLS_HANDSHAKE_FAILED_CLIENT_CODE = 2008;
 export const ICE_FAILED_WITH_TURN_TLS_CLIENT_CODE = 2010;
 export const ICE_FAILED_WITHOUT_TURN_TLS_CLIENT_CODE = 2009;
+export const ICE_AND_REACHABILITY_FAILED_CLIENT_CODE = 2011;
 export const WBX_APP_API_URL = 'wbxappapi'; // MeetingInfo WebexAppApi response object normally contains a body.url that includes the string 'wbxappapi'
 
 export const WEBEX_SUB_SERVICE_TYPES: Record<string, ClientSubServiceType> = {
@@ -125,6 +126,7 @@ export const ERROR_DESCRIPTIONS = {
   DTLS_HANDSHAKE_FAILED: 'DTLSHandshakeFailed',
   ICE_FAILED_WITHOUT_TURN_TLS: 'ICEFailedWithoutTURN_TLS',
   ICE_FAILED_WITH_TURN_TLS: 'ICEFailedWithTURN_TLS',
+  ICE_AND_REACHABILITY_FAILED: 'ICEAndReachabilityFailed',
   SDP_OFFER_CREATION_ERROR: 'SdpOfferCreationError',
   SDP_OFFER_CREATION_ERROR_MISSING_CODEC: 'SdpOfferCreationErrorMissingCodec',
 };
@@ -377,7 +379,7 @@ export const CLIENT_ERROR_CODE_TO_ERROR_PAYLOAD: Record<number, Partial<ClientEv
   },
   [MISSING_ROAP_ANSWER_CLIENT_CODE]: {
     errorDescription: ERROR_DESCRIPTIONS.MISSING_ROAP_ANSWER,
-    category: 'signaling',
+    category: 'media',
     fatal: true,
   },
   [DTLS_HANDSHAKE_FAILED_CLIENT_CODE]: {
@@ -392,7 +394,12 @@ export const CLIENT_ERROR_CODE_TO_ERROR_PAYLOAD: Record<number, Partial<ClientEv
   },
   [ICE_FAILED_WITH_TURN_TLS_CLIENT_CODE]: {
     errorDescription: ERROR_DESCRIPTIONS.ICE_FAILED_WITH_TURN_TLS,
-    category: 'network',
+    category: 'media',
+    fatal: true,
+  },
+  [ICE_AND_REACHABILITY_FAILED_CLIENT_CODE]: {
+    errorDescription: ERROR_DESCRIPTIONS.ICE_AND_REACHABILITY_FAILED,
+    category: 'expected',
     fatal: true,
   },
   2050: {

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,6 +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-metrics';
+import OperationalMetrics from './operational-metrics';
+import BusinessMetrics from './business-metrics';
 
 registerInternalPlugin('metrics', Metrics, {
   config,
@@ -41,6 +44,9 @@ export {
   CallDiagnosticUtils,
   CallDiagnosticLatencies,
   CallDiagnosticMetrics,
+  BehavioralMetrics,
+  OperationalMetrics,
+  BusinessMetrics,
 };
 export type {
   ClientEvent,

package/src/metrics.types.ts

@@ -20,6 +20,42 @@ 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'
+  | 'answer'
+  | 'activate'
+  | 'deactivate';
+
 export type SubmitClientEventOptions = {
   meetingId?: string;
   mediaConnections?: any[];
@@ -66,20 +102,46 @@ export interface ClientEvent {
   options?: SubmitClientEventOptions;
 }
 
-export interface BehavioralEvent {
-  // TODO: not implemented
-  name: 'host.meeting.participant.admitted' | 'sdk.media-flow.started';
-  payload?: never;
-  options?: never;
+export interface DeviceContext {
+  app: {version: string};
+  device: {id: string};
+  locale: string;
+  os: {
+    name: string;
+    version: string;
+  };
 }
 
-export interface OperationalEvent {
-  // TODO: not implemented
-  name: never;
-  payload?: never;
-  options?: never;
+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;
+  timestamp: number;
+  context: DeviceContext;
+  browserDetails: EventPayload;
+  value: EventPayload;
+}
+
+export interface BusinessEvent {
+  type: string[];
+  eventPayload: BusinessEventPayload;
+}
+
+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;
@@ -104,8 +166,9 @@ export type RecursivePartial<T> = {
 export type MetricEventNames =
   | InternalEvent['name']
   | ClientEvent['name']
-  | BehavioralEvent['name']
-  | OperationalEvent['name']
+  | BehavioralEvent['metricName']
+  | OperationalEvent['metricName']
+  | BusinessEvent['eventPayload']['metricName']
   | FeatureEvent['name']
   | MediaQualityEvent['name'];
 
@@ -137,9 +200,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?: EventPayload;
 }) => void;
 
 export type SubmitClientEvent = (args: {
@@ -149,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,11 +6,17 @@
 import {WebexPlugin} from '@webex/webex-core';
 
 import CallDiagnosticMetrics from './call-diagnostic/call-diagnostic-metrics';
+import BehavioralMetrics from './behavioral-metrics';
+import OperationalMetrics from './operational-metrics';
+import BusinessMetrics from './business-metrics';
 import {
   RecursivePartial,
+  MetricEventProduct,
+  MetricEventAgent,
+  MetricEventVerb,
   ClientEvent,
   FeatureEvent,
-  BehavioralEvent,
+  EventPayload,
   OperationalEvent,
   MediaQualityEvent,
   InternalEvent,
@@ -32,6 +38,10 @@ class Metrics extends WebexPlugin {
   callDiagnosticLatencies: CallDiagnosticLatencies;
   // Helper classes to handle the different types of metrics
   callDiagnosticMetrics: CallDiagnosticMetrics;
+  behavioralMetrics: BehavioralMetrics;
+  operationalMetrics: OperationalMetrics;
+  businessMetrics: BusinessMetrics;
+  isReady = false;
 
   /**
    * Constructor
@@ -56,6 +66,7 @@ class Metrics extends WebexPlugin {
     this.webex.once('ready', () => {
       // @ts-ignore
       this.callDiagnosticMetrics = new CallDiagnosticMetrics({}, {parent: this.webex});
+      this.isReady = true;
     });
   }
 
@@ -79,37 +90,103 @@ class Metrics extends WebexPlugin {
     }
   }
 
+  /**
+   * @returns true once we have the deviceId we need to submit behavioral events to Amplitude
+   */
+  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;
+  }
+
   /**
    * 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?: EventPayload;
   }) {
-    this.callDiagnosticLatencies.saveTimestamp({key: name});
-    throw new Error('Not implemented.');
+    if (!this.isReady) {
+      // @ts-ignore
+      this.webex.logger.log(
+        `NewMetrics: @submitBehavioralEvent. Attempted to submit before webex.ready: ${product}.${agent}.${target}.${verb}`
+      );
+
+      return Promise.resolve();
+    }
+
+    if (!this.behavioralMetrics) {
+      // @ts-ignore
+      this.behavioralMetrics = new BehavioralMetrics({}, {parent: this.webex});
+    }
+
+    return this.behavioralMetrics.submitBehavioralEvent({product, agent, target, verb, payload});
   }
 
   /**
    * 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});
+  }
+}