@webex/internal-plugin-metrics 3.0.0-beta.22 → 3.0.0-beta.220

package/src/config.js

@@ -21,3 +21,22 @@ export default {
     batcherRetryPlateau: 32000,
   },
 };
+
+export const OS_NAME = {
+  WINDOWS: 'windows',
+  MAC: 'mac',
+  IOS: 'ios',
+  ANDROID: 'android',
+  CHROME: 'chrome',
+  LINUX: 'linux',
+  OTHERS: 'other',
+};
+
+export const OSMap = {
+  'Chrome OS': OS_NAME.CHROME,
+  macOS: OS_NAME.MAC,
+  Windows: OS_NAME.WINDOWS,
+  iOS: OS_NAME.IOS,
+  Android: OS_NAME.ANDROID,
+  Linux: OS_NAME.LINUX,
+};

package/src/index.ts

@@ -0,0 +1,41 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import '@webex/internal-plugin-device';
+
+import {registerInternalPlugin} from '@webex/webex-core';
+
+import Metrics from './metrics';
+import config from './config';
+import NewMetrics from './new-metrics';
+import {
+  ClientEvent,
+  ClientEventLeaveReason,
+  SubmitBehavioralEvent,
+  SubmitClientEvent,
+  SubmitInternalEvent,
+  SubmitOperationalEvent,
+  SubmitMQE,
+} from './metrics.types';
+import * as CALL_DIAGNOSTIC_CONFIG from './call-diagnostic/config';
+
+registerInternalPlugin('metrics', Metrics, {
+  config,
+});
+
+registerInternalPlugin('newMetrics', NewMetrics, {
+  config,
+});
+
+export {default, getOSNameInternal} from './metrics';
+export {config, CALL_DIAGNOSTIC_CONFIG, NewMetrics};
+export type {
+  ClientEvent,
+  ClientEventLeaveReason,
+  SubmitBehavioralEvent,
+  SubmitClientEvent,
+  SubmitInternalEvent,
+  SubmitMQE,
+  SubmitOperationalEvent,
+};

package/src/metrics.js

@@ -6,14 +6,17 @@
 
 import {WebexPlugin} from '@webex/webex-core';
 import {BrowserDetection} from '@webex/common';
+import {OS_NAME, OSMap, CLIENT_NAME} from './config';
 
-import {CLIENT_NAME} from './config';
 import Batcher from './batcher';
 import ClientMetricsBatcher from './client-metrics-batcher';
-import CallDiagnosticEventsBatcher from './call-diagnostic-events-batcher';
 
 const {getOSName, getOSVersion, getBrowserName, getBrowserVersion} = BrowserDetection();
 
+export function getOSNameInternal() {
+  return OSMap[getOSName()] ?? OS_NAME.OTHERS;
+}
+
 function getSparkUserAgent(webex) {
   const {appName, appVersion, appPlatform} = webex?.config ?? {};
 
@@ -34,7 +37,6 @@ const Metrics = WebexPlugin.extend({
   children: {
     batcher: Batcher,
     clientMetricsBatcher: ClientMetricsBatcher,
-    callDiagnosticEventsBatcher: CallDiagnosticEventsBatcher,
   },
 
   namespace: 'Metrics',
@@ -44,13 +46,12 @@ const Metrics = WebexPlugin.extend({
   },
 
   /**
-   * This corresponds to #sendSemiStructured() in the deprecated metrics handler
+   * Returns the payload for submitting client metrics.
    * @param {string} eventName
-   * @param {Object} props
-   * @param {string} preLoginId
-   * @returns {Object} HttpResponse object
+   * @param {any} props
+   * @returns {any} - the payload
    */
-  submitClientMetrics(eventName, props = {}, preLoginId) {
+  getClientMetricsPayload(eventName, props) {
     if (!eventName) {
       throw Error('Missing behavioral metric name. Please provide one');
     }
@@ -59,22 +60,14 @@ const Metrics = WebexPlugin.extend({
     payload.tags = {
       ...props.tags,
       browser: getBrowserName(),
-      os: getOSName(),
+      os: getOSNameInternal(),
 
       // Node does not like this so we need to check if it exists or not
       // eslint-disable-next-line no-undef
       domain:
         typeof window !== 'undefined' ? window.location.hostname || 'non-browser' : 'non-browser', // Check what else we could measure
-      client_id: this.webex.credentials.config.client_id,
-      user_id: this.webex.internal.device.userId,
     };
 
-    try {
-      payload.tags.org_id = this.webex.credentials.getOrgId();
-    } catch {
-      this.logger.info('metrics: unable to get orgId');
-    }
-
     payload.fields = {
       ...props.fields,
       browser_version: getBrowserVersion(),
@@ -82,6 +75,7 @@ const Metrics = WebexPlugin.extend({
       sdk_version: this.webex.version,
       platform: 'Web',
       spark_user_agent: getSparkUserAgent(this.webex),
+      client_id: this.webex.credentials.config.client_id,
     };
 
     payload.type = props.type || this.webex.config.metrics.type;
@@ -93,7 +87,7 @@ const Metrics = WebexPlugin.extend({
       },
       locale: 'en-US',
       os: {
-        name: getOSName(),
+        name: getOSNameInternal(),
         version: getOSVersion(),
       },
     };
@@ -106,6 +100,19 @@ const Metrics = WebexPlugin.extend({
     // is impossible so unable to use Date.now()
     payload.timestamp = new Date().valueOf();
 
+    return payload;
+  },
+
+  /**
+   * This corresponds to #sendSemiStructured() in the deprecated metrics handler
+   * @param {string} eventName
+   * @param {Object} props
+   * @param {string} preLoginId
+   * @returns {Object} HttpResponse object
+   */
+  submitClientMetrics(eventName, props = {}, preLoginId) {
+    const payload = this.getClientMetricsPayload(eventName, props);
+
     if (preLoginId) {
       const _payload = {
         metrics: [payload],
@@ -154,15 +161,6 @@ const Metrics = WebexPlugin.extend({
       })
     );
   },
-
-  submitCallDiagnosticEvents(payload) {
-    const event = {
-      type: 'diagnostic-event',
-      eventPayload: payload,
-    };
-
-    return this.callDiagnosticEventsBatcher.request(event);
-  },
 });
 
 export default Metrics;

package/src/metrics.types.ts

@@ -0,0 +1,140 @@
+import {ClientEvent as RawClientEvent} from './call-diagnostic/generated-types-temp/ClientEvent';
+import {Event as RawEvent} from './call-diagnostic/generated-types-temp/Event';
+import {MediaQualityEvent as RawMediaQualityEvent} from './call-diagnostic/generated-types-temp/MediaQualityEvent';
+
+export type Event = Omit<RawEvent, 'event'> & {event: RawClientEvent | RawMediaQualityEvent};
+
+export type ClientEventError = NonNullable<RawClientEvent['errors']>[0];
+
+export type SubmitClientEventOptions = {
+  meetingId?: string;
+  mediaConnections?: any[];
+  rawError?: any;
+  showToUser?: boolean;
+  correlationId?: string;
+};
+
+export type SubmitMQEOptions = {
+  meetingId: string;
+  mediaConnections?: any[];
+  networkType?: Event['origin']['networkType'];
+};
+
+export type InternalEvent = {
+  name:
+    | 'internal.client.meetinginfo.request'
+    | 'internal.client.meetinginfo.response'
+    | 'internal.reset.join.latencies'
+    | 'internal.client.interstitial-window.launched'
+    | 'internal.client.meeting.click.joinbutton'
+    | 'internal.host.meeting.participant.admitted'
+    | 'internal.client.meeting.interstitial-window.showed'
+    | 'internal.client.interstitial-window.click.joinbutton';
+  payload?: never;
+  options?: never;
+};
+
+export interface ClientEvent {
+  name: RawClientEvent['name'];
+  payload?: RawClientEvent;
+  options?: SubmitClientEventOptions;
+}
+
+export interface BehavioralEvent {
+  // TODO: not implemented
+  name: 'host.meeting.participant.admitted' | 'sdk.media-flow.started';
+  payload?: never;
+  options?: never;
+}
+
+export interface OperationalEvent {
+  // TODO: not implemented
+  name: never;
+  payload?: never;
+  options?: never;
+}
+
+export interface FeatureEvent {
+  // TODO: not implemented
+  name: never;
+  payload?: never;
+  options?: never;
+}
+
+export interface MediaQualityEvent {
+  name: RawMediaQualityEvent['name'];
+  payload?: RawMediaQualityEvent;
+  options: SubmitMQEOptions;
+}
+
+export type RecursivePartial<T> = {
+  [P in keyof T]?: T[P] extends (infer U)[]
+    ? RecursivePartial<U>[]
+    : T[P] extends object
+    ? RecursivePartial<T[P]>
+    : T[P];
+};
+
+export type MetricEventNames =
+  | InternalEvent['name']
+  | ClientEvent['name']
+  | BehavioralEvent['name']
+  | OperationalEvent['name']
+  | FeatureEvent['name']
+  | MediaQualityEvent['name'];
+
+export type ClientInfo = NonNullable<RawEvent['origin']['clientInfo']>;
+export type ClientType = NonNullable<RawEvent['origin']['clientInfo']>['clientType'];
+export type SubClientType = NonNullable<RawEvent['origin']['clientInfo']>['subClientType'];
+export type NetworkType = NonNullable<RawEvent['origin']>['networkType'];
+
+export type ClientEventPayload = RecursivePartial<ClientEvent['payload']>;
+export type ClientEventLeaveReason = ClientEvent['payload']['leaveReason'];
+export type ClientEventPayloadError = ClientEvent['payload']['errors'];
+
+export type MediaQualityEventAudioSetupDelayPayload = NonNullable<
+  MediaQualityEvent['payload']
+>['audioSetupDelay'];
+export type MediaQualityEventVideoSetupDelayPayload = NonNullable<
+  MediaQualityEvent['payload']
+>['videoSetupDelay'];
+
+export type SubmitMQEPayload = RecursivePartial<MediaQualityEvent['payload']> & {
+  intervals: NonNullable<MediaQualityEvent['payload']>['intervals'];
+};
+
+export type SubmitInternalEvent = (args: {
+  name: InternalEvent['name'];
+  payload?: RecursivePartial<InternalEvent['payload']>;
+  options?: any;
+}) => void;
+
+export type SubmitBehavioralEvent = (args: {
+  name: BehavioralEvent['name'];
+  payload?: RecursivePartial<BehavioralEvent['payload']>;
+  options?: any;
+}) => void;
+
+export type SubmitClientEvent = (args: {
+  name: ClientEvent['name'];
+  payload?: RecursivePartial<ClientEvent['payload']>;
+  options?: SubmitClientEventOptions;
+}) => Promise<any>;
+
+export type SubmitOperationalEvent = (args: {
+  name: OperationalEvent['name'];
+  payload?: RecursivePartial<OperationalEvent['payload']>;
+  options?: any;
+}) => void;
+
+export type SubmitMQE = (args: {
+  name: MediaQualityEvent['name'];
+  payload: SubmitMQEPayload;
+  options: any;
+}) => void;
+
+export type BuildClientEventFetchRequestOptions = (args: {
+  name: ClientEvent['name'];
+  payload?: RecursivePartial<ClientEvent['payload']>;
+  options?: SubmitClientEventOptions;
+}) => Promise<any>;

package/src/new-metrics.ts

@@ -0,0 +1,223 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable class-methods-use-this */
+/* eslint-disable valid-jsdoc */
+
+// @ts-ignore
+import {WebexPlugin} from '@webex/webex-core';
+
+import CallDiagnosticMetrics from './call-diagnostic/call-diagnostic-metrics';
+import {
+  RecursivePartial,
+  ClientEvent,
+  FeatureEvent,
+  BehavioralEvent,
+  OperationalEvent,
+  MediaQualityEvent,
+  InternalEvent,
+  SubmitClientEventOptions,
+} from './metrics.types';
+import CallDiagnosticLatencies from './call-diagnostic/call-diagnostic-metrics-latencies';
+import {setMetricTimings} from './call-diagnostic/call-diagnostic-metrics.util';
+
+/**
+ * Metrics plugin to centralize all types of metrics.
+ * @class
+ */
+class Metrics extends WebexPlugin {
+  // eslint-disable-next-line no-use-before-define
+  static instance: Metrics;
+
+  // Call Diagnostic latencies
+  callDiagnosticLatencies: CallDiagnosticLatencies;
+  // Helper classes to handle the different types of metrics
+  callDiagnosticMetrics: CallDiagnosticMetrics;
+
+  /**
+   * Constructor
+   * @param args
+   * @constructor
+   * @private
+   * @returns
+   */
+  constructor(...args) {
+    super(...args);
+
+    this.onReady();
+  }
+
+  /**
+   * On Ready
+   */
+  private onReady() {
+    // @ts-ignore
+    this.webex.once('ready', () => {
+      // @ts-ignore
+      this.callDiagnosticMetrics = new CallDiagnosticMetrics({}, {parent: this.webex});
+      // @ts-ignore
+      this.callDiagnosticLatencies = new CallDiagnosticLatencies({}, {parent: this.webex});
+    });
+  }
+
+  /**
+   * Used for internal purposes only
+   * @param args
+   */
+  submitInternalEvent({
+    name,
+    payload,
+    options,
+  }: {
+    name: InternalEvent['name'];
+    payload?: RecursivePartial<InternalEvent['payload']>;
+    options?: any;
+  }) {
+    if (name === 'internal.reset.join.latencies') {
+      this.callDiagnosticLatencies.clearTimestamps();
+    } else {
+      this.callDiagnosticLatencies.saveTimestamp({key: name});
+    }
+  }
+
+  /**
+   * Behavioral event
+   * @param args
+   */
+  submitBehavioralEvent({
+    name,
+    payload,
+    options,
+  }: {
+    name: BehavioralEvent['name'];
+    payload?: RecursivePartial<BehavioralEvent['payload']>;
+    options?: any;
+  }) {
+    this.callDiagnosticLatencies.saveTimestamp({key: name});
+    throw new Error('Not implemented.');
+  }
+
+  /**
+   * Operational event
+   * @param args
+   */
+  submitOperationalEvent({
+    name,
+    payload,
+    options,
+  }: {
+    name: OperationalEvent['name'];
+    payload?: RecursivePartial<OperationalEvent['payload']>;
+    options?: any;
+  }) {
+    throw new Error('Not implemented.');
+  }
+
+  /**
+   * Call Analyzer: Media Quality Event
+   * @param args
+   */
+  submitMQE({
+    name,
+    payload,
+    options,
+  }: {
+    name: MediaQualityEvent['name'];
+    payload: RecursivePartial<MediaQualityEvent['payload']> & {
+      intervals: MediaQualityEvent['payload']['intervals'];
+    };
+    options: any;
+  }) {
+    this.callDiagnosticLatencies.saveTimestamp({key: name});
+    this.callDiagnosticMetrics.submitMQE({name, payload, options});
+  }
+
+  /**
+   * Call Analyzer: Feature Usage Event
+   * @param args
+   */
+  submitFeatureEvent({
+    name,
+    payload,
+    options,
+  }: {
+    name: FeatureEvent['name'];
+    payload?: RecursivePartial<FeatureEvent['payload']>;
+    options: any;
+  }) {
+    throw new Error('Not implemented.');
+  }
+
+  /**
+   * Call Analyzer: Client Event
+   * @public
+   * @param args
+   */
+  public submitClientEvent({
+    name,
+    payload,
+    options,
+  }: {
+    name: ClientEvent['name'];
+    payload?: RecursivePartial<ClientEvent['payload']>;
+    options?: SubmitClientEventOptions;
+  }): Promise<any> {
+    this.callDiagnosticLatencies.saveTimestamp({
+      key: name,
+      options: {meetingId: options?.meetingId},
+    });
+
+    return this.callDiagnosticMetrics.submitClientEvent({name, payload, options});
+  }
+
+  /**
+   * Returns a promise that will resolve to fetch options for submitting a metric.
+   *
+   * This is to support quickly submitting metrics when the browser/tab is closing.
+   * Calling submitClientEvent will not work because there some async steps that will
+   * not complete before the browser is closed.  Instead, we pre-gather all the
+   * information/options needed for the request(s), and then simply and quickly
+   * fire the fetch(es) when beforeUnload is triggered.
+   *
+   * We must use fetch instead of request because fetch has a keepalive option that
+   * allows the request it to outlive the page.
+   *
+   * Note: the timings values will be wrong, but setMetricTimingsAndFetch() will
+   * properly adjust them before submitting.
+   *
+   * @public
+   * @param {Object} arg
+   * @param {String} arg.name - event name
+   * @param {Object} arg.payload - event payload
+   * @param {Object} arg.options - other options
+   * @returns {Promise} promise that resolves to options to be used with fetch
+   */
+  public async buildClientEventFetchRequestOptions({
+    name,
+    payload,
+    options,
+  }: {
+    name: ClientEvent['name'];
+    payload?: RecursivePartial<ClientEvent['payload']>;
+    options?: SubmitClientEventOptions;
+  }): Promise<any> {
+    return this.callDiagnosticMetrics.buildClientEventFetchRequestOptions({
+      name,
+      payload,
+      options,
+    });
+  }
+
+  /**
+   * Submits a metric from pre-built request options via the fetch API. Updates
+   * the "$timings" and "originTime" values to Date.now() since the existing times
+   * were set when the options were built (not submitted).
+
+   * @param {any} options - the pre-built request options for submitting a metric
+   * @returns {Promise} promise that resolves to the response object
+   */
+  public setMetricTimingsAndFetch(options: any): Promise<any> {
+    // @ts-ignore
+    return this.webex.setTimingsAndFetch(setMetricTimings(options));
+  }
+}
+
+export default Metrics;