@webex/internal-plugin-metrics 3.0.0-beta.3 → 3.0.0-beta.300

package/src/config.js

@@ -8,15 +8,36 @@ export const CLIENT_NAME = 'webex-js-sdk';
 export default {
   device: {
     preDiscoveryServices: {
-      metricsServiceUrl: process.env.METRICS_SERVICE_URL || 'https://metrics-a.wbx2.com/metrics/api/v1',
-      metrics: process.env.METRICS_SERVICE_URL || 'https://metrics-a.wbx2.com/metrics/api/v1'
-    }
+      metricsServiceUrl:
+        process.env.METRICS_SERVICE_URL || 'https://metrics-a.wbx2.com/metrics/api/v1',
+      metrics: process.env.METRICS_SERVICE_URL || 'https://metrics-a.wbx2.com/metrics/api/v1',
+    },
   },
   metrics: {
     appType: inBrowser ? 'browser' : 'nodejs',
     batcherWait: 500,
     batcherMaxCalls: 50,
     batcherMaxWait: 1500,
-    batcherRetryPlateau: 32000
-  }
+    batcherRetryPlateau: 32000,
+    waitForServiceTimeout: 15,
+  },
+};
+
+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,43 @@
+/*!
+ * 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 * as Utils from './utils';
+import {
+  ClientEvent,
+  ClientEventLeaveReason,
+  SubmitBehavioralEvent,
+  SubmitClientEvent,
+  SubmitInternalEvent,
+  SubmitOperationalEvent,
+  SubmitMQE,
+} from './metrics.types';
+import * as CALL_DIAGNOSTIC_CONFIG from './call-diagnostic/config';
+import * as CallDiagnosticUtils from './call-diagnostic/call-diagnostic-metrics.util';
+
+registerInternalPlugin('metrics', Metrics, {
+  config,
+});
+
+registerInternalPlugin('newMetrics', NewMetrics, {
+  config,
+});
+
+export {default, getOSNameInternal} from './metrics';
+export {config, CALL_DIAGNOSTIC_CONFIG, NewMetrics, Utils, CallDiagnosticUtils};
+export type {
+  ClientEvent,
+  ClientEventLeaveReason,
+  SubmitBehavioralEvent,
+  SubmitClientEvent,
+  SubmitInternalEvent,
+  SubmitMQE,
+  SubmitOperationalEvent,
+};

package/src/metrics.js

@@ -1,28 +1,24 @@
+/* eslint-disable default-param-last */
+
 /*!
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
 
 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();
+const {getOSName, getOSVersion, getBrowserName, getBrowserVersion} = BrowserDetection();
+
+export function getOSNameInternal() {
+  return OSMap[getOSName()] ?? OS_NAME.OTHERS;
+}
 
 function getSparkUserAgent(webex) {
-  const {
-    appName,
-    appVersion,
-    appPlatform
-  } = webex?.config ?? {};
+  const {appName, appVersion, appPlatform} = webex?.config ?? {};
 
   let sparkUserAgent = CLIENT_NAME;
 
@@ -37,29 +33,25 @@ function getSparkUserAgent(webex) {
   return sparkUserAgent;
 }
 
-
 const Metrics = WebexPlugin.extend({
   children: {
     batcher: Batcher,
     clientMetricsBatcher: ClientMetricsBatcher,
-    callDiagnosticEventsBatcher: CallDiagnosticEventsBatcher
   },
 
   namespace: 'Metrics',
 
   submit(key, value) {
-    return this.batcher.request(Object.assign({key}, value));
+    return this.batcher.request({key, ...value});
   },
 
-
   /**
-   * 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');
     }
@@ -68,49 +60,38 @@ 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
+      domain:
+        typeof window !== 'undefined' ? window.location.hostname || 'non-browser' : 'non-browser', // Check what else we could measure
     };
 
-    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(),
       os_version: getOSVersion(),
       sdk_version: this.webex.version,
       platform: 'Web',
-      spark_user_agent: getSparkUserAgent(this.webex)
+      spark_user_agent: getSparkUserAgent(this.webex),
+      client_id: this.webex.credentials.config.client_id,
     };
 
-
     payload.type = props.type || this.webex.config.metrics.type;
 
-
     payload.context = {
       ...props.context,
       app: {
-        version: this.webex.version
+        version: this.webex.version,
       },
       locale: 'en-US',
       os: {
-        name: getOSName(),
-        version: getOSVersion()
-      }
+        name: getOSNameInternal(),
+        version: getOSVersion(),
+      },
     };
 
-
     if (props.eventPayload) {
       payload.eventPayload = props.eventPayload;
     }
@@ -119,9 +100,22 @@ 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]
+        metrics: [payload],
       };
 
       // Do not batch these because pre-login events occur during onboarding, so we will be partially blind
@@ -144,12 +138,12 @@ const Metrics = WebexPlugin.extend({
       api: 'metrics',
       resource: 'clientmetrics',
       headers: {
-        'x-prelogin-userid': preLoginId
+        'x-prelogin-userid': preLoginId,
       },
       body: {},
       qs: {
-        alias: true
-      }
+        alias: true,
+      },
     });
   },
 
@@ -161,20 +155,12 @@ const Metrics = WebexPlugin.extend({
         resource: 'clientmetrics-prelogin',
         headers: {
           authorization: token.toString(),
-          'x-prelogin-userid': preLoginId
+          'x-prelogin-userid': preLoginId,
         },
-        body: payload
-      }));
+        body: payload,
+      })
+    );
   },
-
-  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,159 @@
+import {
+  ClientEvent as RawClientEvent,
+  Event as RawEvent,
+  MediaQualityEvent as RawMediaQualityEvent,
+} from '@webex/event-dictionary-ts';
+
+export type Event = Omit<RawEvent, 'event'> & {event: RawClientEvent | RawMediaQualityEvent};
+
+export type ClientEventError = NonNullable<RawClientEvent['errors']>[0];
+
+export type EnvironmentType = NonNullable<RawEvent['origin']['environment']>;
+
+export type NewEnvironmentType = NonNullable<RawEvent['origin']['newEnvironment']>;
+
+export type ClientLaunchMethodType = NonNullable<
+  RawEvent['origin']['clientInfo']
+>['clientLaunchMethod'];
+
+export type SubmitClientEventOptions = {
+  meetingId?: string;
+  mediaConnections?: any[];
+  rawError?: any;
+  correlationId?: string;
+  preLoginId?: string;
+  environment?: EnvironmentType;
+  newEnvironmentType?: NewEnvironmentType;
+  clientLaunchMethod?: ClientLaunchMethodType;
+  webexConferenceIdStr?: string;
+  globalMeetingId?: string;
+};
+
+export type SubmitMQEOptions = {
+  meetingId: string;
+  mediaConnections?: any[];
+  networkType?: Event['origin']['networkType'];
+  webexConferenceIdStr?: string;
+  globalMeetingId?: string;
+};
+
+export type InternalEvent = {
+  name:
+    | 'internal.client.meetinginfo.request'
+    | 'internal.client.meetinginfo.response'
+    | 'internal.reset.join.latencies'
+    | 'internal.client.meeting.click.joinbutton'
+    | 'internal.host.meeting.participant.admitted'
+    | 'internal.client.meeting.interstitial-window.showed'
+    | 'internal.client.interstitial-window.click.joinbutton'
+    | 'internal.client.add-media.turn-discovery.start'
+    | 'internal.client.add-media.turn-discovery.end';
+
+  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>;