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

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

@@ -21,6 +21,7 @@ import {
   MISSING_ROAP_ANSWER_CLIENT_CODE,
   WBX_APP_API_URL,
   ERROR_DESCRIPTIONS,
+  ICE_AND_REACHABILITY_FAILED_CLIENT_CODE,
 } from './config';
 
 const {getOSName, getOSVersion, getBrowserName, getBrowserVersion} = BrowserDetection();
@@ -225,7 +226,7 @@ export const getBuildType = (
  */
 export const prepareDiagnosticMetricItem = (webex: any, item: any) => {
   const origin: Partial<Event['origin']> = {
-    buildType: exports.getBuildType(
+    buildType: getBuildType(
       item.eventPayload?.event?.eventData?.webClientDomain,
       item.eventPayload?.event?.eventData?.markAsTestEvent
     ),
@@ -284,6 +285,8 @@ export const prepareDiagnosticMetricItem = (webex: any, item: any) => {
 
     case 'client.media.rx.start':
       joinTimes.localSDPGenRemoteSDPRecv = cdl.getLocalSDPGenRemoteSDPRecv();
+      audioSetupDelay.joinRespRxStart = cdl.getAudioJoinRespRxStart();
+      videoSetupDelay.joinRespRxStart = cdl.getVideoJoinRespRxStart();
       break;
 
     case 'client.media-engine.ready':
@@ -293,10 +296,8 @@ export const prepareDiagnosticMetricItem = (webex: any, item: any) => {
       joinTimes.stayLobbyTime = cdl.getStayLobbyTime();
       break;
 
-    case 'client.mediaquality.event':
-      audioSetupDelay.joinRespRxStart = cdl.getAudioJoinRespRxStart();
+    case 'client.media.tx.start':
       audioSetupDelay.joinRespTxStart = cdl.getAudioJoinRespTxStart();
-      videoSetupDelay.joinRespRxStart = cdl.getVideoJoinRespRxStart();
       videoSetupDelay.joinRespTxStart = cdl.getVideoJoinRespTxStart();
   }
 
@@ -314,7 +315,6 @@ export const prepareDiagnosticMetricItem = (webex: any, item: any) => {
 
   item.eventPayload.origin = Object.assign(origin, item.eventPayload.origin);
 
-  // @ts-ignore
   webex.logger.log(
     `CallDiagnosticLatencies,prepareDiagnosticMetricItem: ${JSON.stringify({
       latencies: Object.fromEntries(cdl.latencyTimestamps),
@@ -370,12 +370,14 @@ export const extractVersionMetadata = (version: string) => {
  */
 export const generateClientErrorCodeForIceFailure = ({
   signalingState,
-  iceConnectionState,
+  iceConnected,
   turnServerUsed,
+  unreachable,
 }: {
   signalingState: RTCPeerConnection['signalingState'];
-  iceConnectionState: RTCPeerConnection['iceConnectionState'];
+  iceConnected: boolean;
   turnServerUsed: boolean;
+  unreachable: boolean;
 }) => {
   let errorCode = ICE_FAILURE_CLIENT_CODE; // default;
 
@@ -383,20 +385,17 @@ export const generateClientErrorCodeForIceFailure = ({
     errorCode = MISSING_ROAP_ANSWER_CLIENT_CODE;
   }
 
-  if (
-    signalingState === 'stable' &&
-    (iceConnectionState === 'connected' || iceConnectionState === 'disconnected')
-  ) {
+  if (signalingState === 'stable' && iceConnected) {
     errorCode = DTLS_HANDSHAKE_FAILED_CLIENT_CODE;
   }
 
-  if (
-    signalingState !== 'have-local-offer' &&
-    iceConnectionState !== 'connected' &&
-    iceConnectionState !== 'disconnected'
-  ) {
+  if (signalingState !== 'have-local-offer' && !iceConnected) {
     if (turnServerUsed) {
-      errorCode = ICE_FAILED_WITH_TURN_TLS_CLIENT_CODE;
+      if (unreachable) {
+        errorCode = ICE_AND_REACHABILITY_FAILED_CLIENT_CODE;
+      } else {
+        errorCode = ICE_FAILED_WITH_TURN_TLS_CLIENT_CODE;
+      }
     } else {
       errorCode = ICE_FAILED_WITHOUT_TURN_TLS_CLIENT_CODE;
     }

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/index.ts

@@ -22,6 +22,7 @@ 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';
 
 registerInternalPlugin('metrics', Metrics, {
   config,
@@ -41,6 +42,7 @@ export {
   CallDiagnosticUtils,
   CallDiagnosticLatencies,
   CallDiagnosticMetrics,
+  BehavioralMetrics,
 };
 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,13 +102,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 +153,7 @@ export type RecursivePartial<T> = {
 export type MetricEventNames =
   | InternalEvent['name']
   | ClientEvent['name']
-  | BehavioralEvent['name']
+  | BehavioralEvent['metricName']
   | OperationalEvent['name']
   | FeatureEvent['name']
   | MediaQualityEvent['name'];
@@ -137,9 +186,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'],
+        });
+      });
+    });
+  });
+});

package/test/unit/spec/call-diagnostic/call-diagnostic-metrics-batcher.ts

@@ -248,9 +248,15 @@ describe('plugin-metrics', () => {
         });
 
         it('appends the correct join times to the request for client.media.rx.start', async () => {
-          webex.internal.newMetrics.callDiagnosticLatencies.getDiffBetweenTimestamps = sinon
+          webex.internal.newMetrics.callDiagnosticLatencies.getLocalSDPGenRemoteSDPRecv = sinon
+            .stub()
+            .returns(5);
+          webex.internal.newMetrics.callDiagnosticLatencies.getAudioJoinRespRxStart = sinon
             .stub()
             .returns(10);
+          webex.internal.newMetrics.callDiagnosticLatencies.getVideoJoinRespRxStart = sinon
+            .stub()
+            .returns(20);
           const promise = webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
             //@ts-ignore
             {event: {name: 'client.media.rx.start'}}
@@ -265,7 +271,13 @@ describe('plugin-metrics', () => {
           assert.deepEqual(webex.request.getCalls()[0].args[0].body.metrics[0].eventPayload.event, {
             name: 'client.media.rx.start',
             joinTimes: {
-              localSDPGenRemoteSDPRecv: 10,
+              localSDPGenRemoteSDPRecv: 5,
+            },
+            audioSetupDelay: {
+              joinRespRxStart: 10,
+            },
+            videoSetupDelay: {
+              joinRespRxStart: 20,
             },
           });
           assert.lengthOf(
@@ -274,19 +286,16 @@ describe('plugin-metrics', () => {
           );
         });
 
-        it('appends the correct join times to the request for client.media-engine.ready', async () => {
-          webex.internal.newMetrics.callDiagnosticLatencies.getDiffBetweenTimestamps = sinon
-            .stub()
-            .returns(10);
-          webex.internal.newMetrics.callDiagnosticLatencies.getInterstitialToMediaOKJMT = sinon
+        it('appends the correct join times to the request for client.media.tx.start', async () => {
+          webex.internal.newMetrics.callDiagnosticLatencies.getAudioJoinRespTxStart = sinon
             .stub()
             .returns(10);
-          webex.internal.newMetrics.callDiagnosticLatencies.getClickToInterstitial = sinon
+          webex.internal.newMetrics.callDiagnosticLatencies.getVideoJoinRespTxStart = sinon
             .stub()
-            .returns(10);
+            .returns(20);
           const promise = webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
             //@ts-ignore
-            {event: {name: 'client.media-engine.ready'}}
+            {event: {name: 'client.media.tx.start'}}
           );
           await flushPromises();
           clock.tick(config.metrics.batcherWait);
@@ -296,12 +305,12 @@ describe('plugin-metrics', () => {
           //@ts-ignore
           assert.calledOnce(webex.request);
           assert.deepEqual(webex.request.getCalls()[0].args[0].body.metrics[0].eventPayload.event, {
-            name: 'client.media-engine.ready',
-            joinTimes: {
-              totalMediaJMT: 30,
-              interstitialToMediaOKJMT: 10,
-              callInitMediaEngineReady: 10,
-              stayLobbyTime: 10,
+            name: 'client.media.tx.start',
+            audioSetupDelay: {
+              joinRespTxStart: 10,
+            },
+            videoSetupDelay: {
+              joinRespTxStart: 20,
             },
           });
           assert.lengthOf(
@@ -310,13 +319,28 @@ describe('plugin-metrics', () => {
           );
         });
 
-        it('appends the correct audio and video setup delays to the request for client.mediaquality.event', async () => {
+        it('appends the correct join times to the request for client.media-engine.ready', async () => {
           webex.internal.newMetrics.callDiagnosticLatencies.getDiffBetweenTimestamps = sinon
             .stub()
             .returns(10);
+          webex.internal.newMetrics.callDiagnosticLatencies.getInterstitialToMediaOKJMT = sinon
+            .stub()
+            .returns(22);
+          webex.internal.newMetrics.callDiagnosticLatencies.getClickToInterstitial = sinon
+            .stub()
+            .returns(35);
+          webex.internal.newMetrics.callDiagnosticLatencies.getInterstitialToJoinOK = sinon
+            .stub()
+            .returns(5);
+          webex.internal.newMetrics.callDiagnosticLatencies.getInterstitialToJoinOK = sinon
+            .stub()
+            .returns(7);
+            webex.internal.newMetrics.callDiagnosticLatencies.getStayLobbyTime = sinon
+            .stub()
+            .returns(1);
           const promise = webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
             //@ts-ignore
-            {event: {name: 'client.mediaquality.event'}}
+            {event: {name: 'client.media-engine.ready'}}
           );
           await flushPromises();
           clock.tick(config.metrics.batcherWait);
@@ -326,14 +350,12 @@ describe('plugin-metrics', () => {
           //@ts-ignore
           assert.calledOnce(webex.request);
           assert.deepEqual(webex.request.getCalls()[0].args[0].body.metrics[0].eventPayload.event, {
-            name: 'client.mediaquality.event',
-            audioSetupDelay: {
-              joinRespRxStart: 10,
-              joinRespTxStart: 10,
-            },
-            videoSetupDelay: {
-              joinRespRxStart: 10,
-              joinRespTxStart: 10,
+            name: 'client.media-engine.ready',
+            joinTimes: {
+              totalMediaJMT: 61,
+              interstitialToMediaOKJMT: 22,
+              callInitMediaEngineReady: 10,
+              stayLobbyTime: 1,
             },
           });
           assert.lengthOf(
@@ -341,32 +363,6 @@ describe('plugin-metrics', () => {
             0
           );
         });
-
-        it('doesnt include audioSetup and videoSetup delays for other events', async () => {
-          const promise = webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
-            //@ts-ignore
-            {event: {name: 'client.alert.displayed'}}
-          );
-          await flushPromises();
-          clock.tick(config.metrics.batcherWait);
-
-          await promise;
-
-          //@ts-ignore
-          assert.calledOnce(webex.request);
-          assert.deepEqual(
-            webex.request.getCalls()[0].args[0].body.metrics[0].eventPayload.event.audioSetupDelay,
-            undefined
-          );
-          assert.deepEqual(
-            webex.request.getCalls()[0].args[0].body.metrics[0].eventPayload.event.videoSetupDelay,
-            undefined
-          );
-          assert.lengthOf(
-            webex.internal.newMetrics.callDiagnosticMetrics.callDiagnosticEventsBatcher.queue,
-            0
-          );
-        });
       });
 
       describe('when the request fails', () => {

package/test/unit/spec/call-diagnostic/call-diagnostic-metrics-latencies.ts

@@ -668,7 +668,7 @@ describe('internal-plugin-metrics', () => {
       assert.deepEqual(cdl.getInterstitialToMediaOKJMT(), 10);
     });
 
-    it('calculates getU2CTime correctly', () => {
+    describe('calculates getU2CTime correctly', () => {
       it('returns undefined when no precomputed value available', () => {
         assert.deepEqual(cdl.getU2CTime(), undefined);
       });

package/test/unit/spec/call-diagnostic/call-diagnostic-metrics.ts

@@ -1454,6 +1454,9 @@ describe('internal-plugin-metrics', () => {
             eventData: {webClientDomain: 'whatever'},
             intervals: [{}],
             callingServiceType: 'LOCUS',
+            meetingJoinInfo: {
+              clientSignallingProtocol: 'WebRTC',
+            },
             sourceMetadata: {
               applicationSoftwareType: 'webex-js-sdk',
               applicationSoftwareVersion: 'webex-version',
@@ -1490,6 +1493,9 @@ describe('internal-plugin-metrics', () => {
               eventData: {webClientDomain: 'whatever'},
               intervals: [{}],
               callingServiceType: 'LOCUS',
+              meetingJoinInfo: {
+                clientSignallingProtocol: 'WebRTC',
+              },
               sourceMetadata: {
                 applicationSoftwareType: 'webex-js-sdk',
                 applicationSoftwareVersion: 'webex-version',
@@ -1524,6 +1530,9 @@ describe('internal-plugin-metrics', () => {
             eventData: {webClientDomain: 'whatever'},
             intervals: [{}],
             callingServiceType: 'LOCUS',
+            meetingJoinInfo: {
+              clientSignallingProtocol: 'WebRTC',
+            },
             sourceMetadata: {
               applicationSoftwareType: 'webex-js-sdk',
               applicationSoftwareVersion: 'webex-version',