@webex/internal-plugin-metrics 3.4.0 → 3.5.0-next.10

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,118 @@
+import GenericMetrics from './generic-metrics';
+import {EventPayload, Table} from './metrics.types';
+
+/**
+ * @description Util class to handle Buisness Metrics
+ * @export
+ * @class BusinessMetrics
+ */
+export default class BusinessMetrics extends GenericMetrics {
+  /**
+   * unfortunately, the pinot team does not allow changes to the schema of wbxapp_callend_metrics
+   * so we have to shim this layer specifically for this
+   * @param {EventPayload} payload payload of the metric
+   * @returns {Promise<any>}
+   */
+  private submitCallEndEvent({payload}: {payload: EventPayload}) {
+    const event = {
+      type: ['business'],
+      eventPayload: {
+        key: 'callEnd',
+        client_timestamp: Date.now(),
+        appType: 'Web Client',
+        value: {
+          ...payload,
+        },
+      },
+    };
+
+    return this.submitEvent({
+      kind: 'buisness-events:wbxapp_callend_metrics -> ',
+      name: 'wbxapp_callend_metrics',
+      event,
+    });
+  }
+
+  /**
+   * Submit a buisness metric to our metrics endpoint, going to the default business_ucf table
+   * all event payload keys are converted into a hex string value
+   * unfortunately, the pinot team does not allow changes to the schema of business_metrics
+   * so we have to shim this layer specifically for this
+   * @param {string} name of the metric
+   * @param {EventPayload} payload payload of the metric
+   * @returns {Promise<any>}
+   */
+  private submitBusinessMetricsEvent({name, payload}: {name: string; payload: EventPayload}) {
+    const event = {
+      type: ['business'],
+      eventPayload: {
+        key: name,
+        client_timestamp: Date.now(),
+        appType: 'Web Client',
+        value: {
+          ...this.getContext(),
+          ...this.getBrowserDetails(),
+          ...payload,
+        },
+      },
+    };
+
+    return this.submitEvent({kind: 'buisness-events:business_metrics -> ', name, event});
+  }
+
+  /**
+   * Submit a buisness metric to our metrics endpoint, going to the default business_ucf table
+   * all event payload keys are converted into a hex string value
+   * @param {string} name of the metric
+   * @param {EventPayload} user payload of the metric
+   * @returns {Promise<any>}
+   */
+  private submitDefaultEvent({name, payload}: {name: string; payload: EventPayload}) {
+    const event = {
+      type: ['business'],
+      eventPayload: {
+        key: name,
+        appType: 'Web Client',
+        client_timestamp: Date.now(),
+        context: this.getContext(),
+        browserDetails: this.getBrowserDetails(),
+        value: payload,
+      },
+    };
+
+    return this.submitEvent({kind: 'buisness-events:default -> ', name, event});
+  }
+
+  /**
+   * Submit a buisness metric to our metrics endpoint.
+   * routes to the correct table with the correct schema payload by table
+   * @param {string} name of the metric, ignored if going to wbxapp_callend_metrics
+   * @param {EventPayload} payload user payload of the metric
+   * @param {Table} table optional - to submit the metric to and adapt the sent schema
+   * @returns {Promise<any>}
+   */
+  public submitBusinessEvent({
+    name,
+    payload,
+    table,
+  }: {
+    name: string;
+    payload: EventPayload;
+    table?: Table;
+  }): Promise<void> {
+    if (!table) {
+      table = 'default';
+    }
+    switch (table) {
+      case 'wbxapp_callend_metrics':
+        return this.submitCallEndEvent({payload});
+      case 'business_metrics':
+        return this.submitBusinessMetricsEvent({name, payload});
+      case 'business_ucf':
+        return this.submitDefaultEvent({name, payload});
+      case 'default':
+      default:
+        return this.submitDefaultEvent({name, payload});
+    }
+  }
+}

package/src/call-diagnostic/call-diagnostic-metrics-latencies.ts

@@ -49,7 +49,7 @@ export default class CallDiagnosticLatencies extends WebexPlugin {
   private getMeeting() {
     if (this.meetingId) {
       // @ts-ignore
-      return this.webex.meetings.meetingCollection.get(this.meetingId);
+      return this.webex.meetings.getBasicMeetingInformation(this.meetingId);
     }
 
     return undefined;

package/src/call-diagnostic/call-diagnostic-metrics.ts

@@ -75,6 +75,7 @@ type GetIdentifiersOptions = {
   meeting?: any;
   mediaConnections?: any[];
   correlationId?: string;
+  sessionCorrelationId?: string;
   preLoginId?: string;
   globalMeetingId?: string;
   webexConferenceIdStr?: string;
@@ -138,7 +139,7 @@ export default class CallDiagnosticMetrics extends StatelessWebexPlugin {
   getIsConvergedArchitectureEnabled({meetingId}: {meetingId?: string}): boolean {
     if (meetingId) {
       // @ts-ignore
-      const meeting = this.webex.meetings.meetingCollection.get(meetingId);
+      const meeting = this.webex.meetings.getBasicMeetingInformation(meetingId);
 
       return meeting?.meetingInfo?.enableConvergedArchitecture;
     }
@@ -244,7 +245,7 @@ export default class CallDiagnosticMetrics extends StatelessWebexPlugin {
 
       if (meetingId) {
         // @ts-ignore
-        const meeting = this.webex.meetings.meetingCollection.get(meetingId);
+        const meeting = this.webex.meetings.getBasicMeetingInformation(meetingId);
         if (meeting?.environment) {
           origin.environment = meeting.environment;
         }
@@ -285,19 +286,29 @@ export default class CallDiagnosticMetrics extends StatelessWebexPlugin {
       webexConferenceIdStr,
       globalMeetingId,
       preLoginId,
+      sessionCorrelationId,
     } = options;
     const identifiers: Event['event']['identifiers'] = {
-      correlationId: 'unknown',
+      correlationId: 'unknown', // concerned with setting this to unknown. This will fail diagnostic events parsing because it's not a uuid pattern
     };
 
     if (meeting) {
       identifiers.correlationId = meeting.correlationId;
+      if (meeting.sessionCorrelationId) {
+        identifiers.sessionCorrelationId = meeting.sessionCorrelationId;
+      }
+    }
+
+    if (sessionCorrelationId) {
+      identifiers.sessionCorrelationId = sessionCorrelationId;
     }
 
     if (correlationId) {
       identifiers.correlationId = correlationId;
     }
 
+    // TODO: should we use patterns.uuid to validate correlationId and session correlation id? they will fail the diagnostic events validation pipeline if improperly formatted
+
     if (this.device) {
       const {device} = this;
       const {installationId} = device?.config || {};
@@ -419,7 +430,7 @@ export default class CallDiagnosticMetrics extends StatelessWebexPlugin {
     // events that will most likely happen in join phase
     if (meetingId) {
       // @ts-ignore
-      const meeting = this.webex.meetings.meetingCollection.get(meetingId);
+      const meeting = this.webex.meetings.getBasicMeetingInformation(meetingId);
 
       if (!meeting) {
         console.warn(
@@ -620,10 +631,11 @@ export default class CallDiagnosticMetrics extends StatelessWebexPlugin {
       });
     }
 
-    // otherwise return unkown error
+    // otherwise return unkown error but passing serviceErrorCode and serviceErrorName so that we know the issue
     return this.getErrorPayloadForClientErrorCode({
       clientErrorCode: UNKNOWN_ERROR,
-      serviceErrorCode: UNKNOWN_ERROR,
+      serviceErrorCode: serviceErrorCode || UNKNOWN_ERROR,
+      serviceErrorName: rawError?.name,
       payloadOverrides: rawError.payloadOverrides,
       rawErrorMessage,
       httpStatusCode,
@@ -646,10 +658,16 @@ export default class CallDiagnosticMetrics extends StatelessWebexPlugin {
     options?: SubmitClientEventOptions;
     errors?: ClientEventPayloadError;
   }) {
-    const {meetingId, mediaConnections, globalMeetingId, webexConferenceIdStr} = options;
+    const {
+      meetingId,
+      mediaConnections,
+      globalMeetingId,
+      webexConferenceIdStr,
+      sessionCorrelationId,
+    } = options;
 
     // @ts-ignore
-    const meeting = this.webex.meetings.meetingCollection.get(meetingId);
+    const meeting = this.webex.meetings.getBasicMeetingInformation(meetingId);
 
     if (!meeting) {
       console.warn(
@@ -673,6 +691,7 @@ export default class CallDiagnosticMetrics extends StatelessWebexPlugin {
       mediaConnections: meeting?.mediaConnections || mediaConnections,
       webexConferenceIdStr,
       globalMeetingId,
+      sessionCorrelationId,
     });
 
     // create client event object
@@ -714,11 +733,13 @@ export default class CallDiagnosticMetrics extends StatelessWebexPlugin {
     options?: SubmitClientEventOptions;
     errors?: ClientEventPayloadError;
   }) {
-    const {correlationId, globalMeetingId, webexConferenceIdStr, preLoginId} = options;
+    const {correlationId, globalMeetingId, webexConferenceIdStr, preLoginId, sessionCorrelationId} =
+      options;
 
     // grab identifiers
     const identifiers = this.getIdentifiers({
       correlationId,
+      sessionCorrelationId,
       preLoginId,
       globalMeetingId,
       webexConferenceIdStr,

package/src/call-diagnostic/call-diagnostic-metrics.util.ts

@@ -195,10 +195,12 @@ export const isBrowserMediaErrorName = (errorName: any) => {
 };
 
 /**
+ * @param {Object} webex sdk instance
  * @param webClientDomain
  * @returns
  */
 export const getBuildType = (
+  webex,
   webClientDomain,
   markAsTestEvent = false
 ): Event['origin']['buildType'] => {
@@ -207,6 +209,10 @@ export const getBuildType = (
     return 'test';
   }
 
+  if (webex.internal.metrics?.config?.caBuildType) {
+    return webex.internal.metrics.config.caBuildType;
+  }
+
   if (
     webClientDomain?.includes('localhost') ||
     webClientDomain?.includes('127.0.0.1') ||
@@ -225,12 +231,19 @@ export const getBuildType = (
  * @returns {Object} prepared item
  */
 export const prepareDiagnosticMetricItem = (webex: any, item: any) => {
+  const buildType = getBuildType(
+    webex,
+    item.eventPayload?.event?.eventData?.webClientDomain,
+    item.eventPayload?.event?.eventData?.markAsTestEvent
+  );
+
+  // Set upgradeChannel to 'gold' if buildType is 'prod', otherwise to the buildType value
+  const upgradeChannel = buildType === 'prod' ? 'gold' : buildType;
+
   const origin: Partial<Event['origin']> = {
-    buildType: getBuildType(
-      item.eventPayload?.event?.eventData?.webClientDomain,
-      item.eventPayload?.event?.eventData?.markAsTestEvent
-    ),
+    buildType,
     networkType: 'unknown',
+    upgradeChannel,
   };
 
   // check event names and append latencies?

package/src/call-diagnostic/config.ts

@@ -129,6 +129,7 @@ export const ERROR_DESCRIPTIONS = {
   ICE_AND_REACHABILITY_FAILED: 'ICEAndReachabilityFailed',
   SDP_OFFER_CREATION_ERROR: 'SdpOfferCreationError',
   SDP_OFFER_CREATION_ERROR_MISSING_CODEC: 'SdpOfferCreationErrorMissingCodec',
+  WDM_RESTRICTED_REGION: 'WdmRestrictedRegion',
 };
 
 export const SERVICE_ERROR_CODES_TO_CLIENT_ERROR_CODES_MAP = {
@@ -288,6 +289,12 @@ export const SERVICE_ERROR_CODES_TO_CLIENT_ERROR_CODES_MAP = {
   100005: 4103, // Depracated because of an issue in the UCF Clients
   // If both email-hash and domain-hash are null or undefined.
   100004: 4103,
+
+  // ---- WDM ----
+  // WDM_BLOCKED_ACCESS_BY_COUNTRY_CODE_BANNED_COUNTRY_ERROR_CODE
+  4404002: 13000,
+  // WDM_BLOCKED_ACCESS_BY_COUNTRY_CODE_RESTRICTED_COUNTRY_ERROR_CODE
+  4404003: 13000,
 };
 
 export const CLIENT_ERROR_CODE_TO_ERROR_PAYLOAD: Record<number, Partial<ClientEventError>> = {
@@ -687,6 +694,11 @@ export const CLIENT_ERROR_CODE_TO_ERROR_PAYLOAD: Record<number, Partial<ClientEv
     category: 'expected',
     fatal: true,
   },
+  13000: {
+    errorDescription: ERROR_DESCRIPTIONS.WDM_RESTRICTED_REGION,
+    category: 'expected',
+    fatal: true,
+  },
 };
 
 export const CALL_DIAGNOSTIC_EVENT_FAILED_TO_SEND = 'js_sdk_call_diagnostic_event_failed_to_send';

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,10 @@ 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';
+import RtcMetrics from './rtcMetrics';
 
 registerInternalPlugin('metrics', Metrics, {
   config,
@@ -43,6 +46,9 @@ export {
   CallDiagnosticLatencies,
   CallDiagnosticMetrics,
   BehavioralMetrics,
+  OperationalMetrics,
+  BusinessMetrics,
+  RtcMetrics,
 };
 export type {
   ClientEvent,

package/src/metrics.types.ts

@@ -61,6 +61,7 @@ export type SubmitClientEventOptions = {
   mediaConnections?: any[];
   rawError?: any;
   correlationId?: string;
+  sessionCorrelationId?: string;
   preLoginId?: string;
   environment?: EnvironmentType;
   newEnvironmentType?: NewEnvironmentType;
@@ -102,7 +103,7 @@ export interface ClientEvent {
   options?: SubmitClientEventOptions;
 }
 
-export interface BehavioralEventContext {
+export interface DeviceContext {
   app: {version: string};
   device: {id: string};
   locale: string;
@@ -112,23 +113,38 @@ export interface BehavioralEventContext {
   };
 }
 
-export interface BehavioralEvent {
-  context: BehavioralEventContext;
+export type MetricType = 'behavioral' | 'operational' | 'business';
+
+export type Table = 'wbxapp_callend_metrics' | 'business_metrics' | 'business_ucf' | 'default';
+
+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 +170,8 @@ export type MetricEventNames =
   | InternalEvent['name']
   | ClientEvent['name']
   | BehavioralEvent['metricName']
-  | OperationalEvent['name']
+  | OperationalEvent['metricName']
+  | BusinessEvent['eventPayload']['metricName']
   | FeatureEvent['name']
   | MediaQualityEvent['name'];
 
@@ -190,7 +207,7 @@ export type SubmitBehavioralEvent = (args: {
   agent: MetricEventAgent;
   target: string;
   verb: MetricEventVerb;
-  payload?: BehavioralEventPayload;
+  payload?: EventPayload;
 }) => void;
 
 export type SubmitClientEvent = (args: {
@@ -200,9 +217,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: {