@webex/internal-plugin-metrics 3.11.0 → 3.12.0-auth-prejoin-fetch.1

package/src/unhandled-exception-telemetry/index.ts

@@ -0,0 +1,403 @@
+/* eslint-disable require-jsdoc, valid-jsdoc */
+
+import {safeSetTimeout} from '@webex/common-timers';
+import uuid from 'uuid';
+
+import {
+  createFingerprint,
+  removeUrlDetails,
+  removeUrlDetailsFromText,
+  sanitizeResourceUrl,
+  stringifyReason,
+  truncate,
+} from './utils';
+
+export const UNHANDLED_EXCEPTION_METRIC_NAME = 'JS_SDK_OBSERVED_CLIENT_UNHANDLED_EXCEPTION';
+
+const DEDUPE_WINDOW_MS = 1_000;
+const MAX_ERROR_MESSAGE_LENGTH = 4_096;
+const MAX_ERROR_NAME_LENGTH = 256;
+const MAX_METADATA_LENGTH = 32_000;
+const MAX_STACK_LENGTH = 8_192;
+
+const TELEMETRY_LOG_IDENTIFIER = 'Unhandled Exception Telemetry -->';
+
+type ErrorDetails = {
+  column?: number;
+  filename?: string;
+  kind: 'error' | 'unhandledrejection' | 'resource_error';
+  line?: number;
+  message?: string;
+  name: string;
+  /** Uppercase DOM tag name, such as SCRIPT, LINK, or IMG; RESOURCE when unavailable. */
+  resourceType?: string;
+  resourceUrl?: string;
+  stack?: string;
+};
+
+export type UnhandledExceptionEvent = {
+  schemaVersion: 1;
+  capturedAt: number;
+  eventId: string;
+  occurrenceCount: number;
+  common: {
+    appName: string;
+    appVersion?: string;
+    runtime: 'browser';
+    sdkVersion?: string;
+  };
+  error: ErrorDetails & {fingerprint: string};
+  metadata?: Record<string, unknown>;
+  metadataCaptureStatus?: 'invalid_type' | 'provider_error' | 'too_large';
+};
+
+type WebexForUnhandledExceptionTelemetry = {
+  canAuthorize?: boolean;
+  version?: string;
+  config?: {
+    appName?: string;
+    appVersion?: string;
+    sdkType?: string;
+    metrics?: {
+      unhandledExceptionTelemetry?: {
+        enabled?: boolean;
+        getMetadata?: () => Record<string, unknown> | undefined;
+      };
+    };
+  };
+  internal?: {
+    metrics?: {
+      submitClientMetrics?: (name: string, properties: object, preLoginId?: string) => unknown;
+    };
+  };
+  logger?: {
+    error?: (...args: unknown[]) => unknown;
+  };
+};
+
+function logTelemetryFailure(webex: WebexForUnhandledExceptionTelemetry, message: string): void {
+  try {
+    webex.logger?.error?.(TELEMETRY_LOG_IDENTIFIER, message);
+  } catch {
+    // Logging must not turn a telemetry failure into an application failure.
+  }
+}
+
+/**
+ * SDK-owned browser exception reporter with a single in-memory deduplication window.
+ */
+class UnhandledExceptionTelemetry {
+  private readonly pendingEvents = new Map<string, UnhandledExceptionEvent>();
+  private readonly eventTarget: Window;
+  private readonly errorListener = (event: ErrorEvent) => this.captureError(event);
+  private readonly preLoginId: string;
+  private readonly rejectionListener = (event: PromiseRejectionEvent) =>
+    this.captureRejection(event);
+
+  private readonly webex: WebexForUnhandledExceptionTelemetry;
+  private flushTimer?: number | NodeJS.Timeout;
+
+  /**
+   * Registers browser listeners after the SDK is ready.
+   * @param webex SDK instance used for configuration and submission.
+   * @param eventTarget Browser window.
+   */
+  constructor(webex: WebexForUnhandledExceptionTelemetry, eventTarget: Window) {
+    this.webex = webex;
+    this.eventTarget = eventTarget;
+    this.preLoginId = uuid.v4();
+    eventTarget.addEventListener('error', this.errorListener, {capture: true});
+    eventTarget.addEventListener('unhandledrejection', this.rejectionListener, {capture: true});
+  }
+
+  /**
+   * Removes global listeners and either flushes or discards pending events.
+   * @param flushPending Whether to submit pending telemetry before teardown.
+   * @returns {void}
+   */
+  stop(flushPending: boolean): void {
+    this.eventTarget.removeEventListener('error', this.errorListener, {capture: true});
+    this.eventTarget.removeEventListener('unhandledrejection', this.rejectionListener, {
+      capture: true,
+    });
+    this.clearFlushTimer();
+
+    if (flushPending) {
+      this.pendingEvents.forEach((event) => this.submit(event));
+    }
+
+    this.pendingEvents.clear();
+  }
+
+  private captureError(event: ErrorEvent): void {
+    try {
+      const resourceTarget = event.target;
+      const currentSrc = resourceTarget ? Reflect.get(resourceTarget, 'currentSrc') : undefined;
+      const src = resourceTarget ? Reflect.get(resourceTarget, 'src') : undefined;
+      const href = resourceTarget ? Reflect.get(resourceTarget, 'href') : undefined;
+      const rawResourceUrl =
+        (typeof currentSrc === 'string' && currentSrc.length > 0 && currentSrc) ||
+        (typeof src === 'string' && src.length > 0 && src) ||
+        (typeof href === 'string' && href.length > 0 && href) ||
+        undefined;
+
+      if (rawResourceUrl) {
+        const resourceUrl = sanitizeResourceUrl(rawResourceUrl);
+
+        if (!resourceUrl) {
+          return;
+        }
+
+        const resourceType = String(
+          (resourceTarget && Reflect.get(resourceTarget, 'tagName')) ?? 'RESOURCE'
+        ).toUpperCase();
+
+        this.capture({
+          kind: 'resource_error',
+          message: `Failed to load ${resourceType} resource`,
+          name: 'ResourceError',
+          resourceType,
+          resourceUrl,
+        });
+
+        return;
+      }
+
+      const {error} = event;
+      let message = 'Unknown uncaught error';
+
+      if (typeof error?.message === 'string') {
+        message = error.message;
+      } else if (typeof event.message === 'string') {
+        message = event.message;
+      }
+
+      this.capture({
+        column: event.colno,
+        filename: removeUrlDetails(event.filename),
+        kind: 'error',
+        line: event.lineno,
+        message,
+        name: typeof error?.name === 'string' ? error.name : 'Error',
+        stack: typeof error?.stack === 'string' ? error.stack : undefined,
+      });
+    } catch {
+      logTelemetryFailure(this.webex, 'Failed to extract an uncaught error.');
+    }
+  }
+
+  private captureRejection(event: PromiseRejectionEvent): void {
+    try {
+      const {reason} = event;
+
+      this.capture({
+        kind: 'unhandledrejection',
+        message: typeof reason?.message === 'string' ? reason.message : stringifyReason(reason),
+        name: typeof reason?.name === 'string' ? reason.name : 'UnhandledRejection',
+        stack: typeof reason?.stack === 'string' ? reason.stack : undefined,
+      });
+    } catch {
+      logTelemetryFailure(this.webex, 'Failed to extract an unhandled rejection.');
+    }
+  }
+
+  private capture(details: ErrorDetails): void {
+    try {
+      const error = {
+        ...details,
+        name: truncate(removeUrlDetailsFromText(details.name), MAX_ERROR_NAME_LENGTH) ?? 'Error',
+        message: truncate(removeUrlDetailsFromText(details.message), MAX_ERROR_MESSAGE_LENGTH),
+        stack: truncate(removeUrlDetailsFromText(details.stack), MAX_STACK_LENGTH),
+      };
+      const fingerprint = createFingerprint(
+        [
+          error.kind,
+          error.name,
+          error.message,
+          error.stack,
+          error.filename,
+          error.line,
+          error.column,
+          error.resourceUrl,
+        ].join('|')
+      );
+      const capturedAt = new Date().getTime();
+      const existingEvent = this.pendingEvents.get(fingerprint);
+
+      if (existingEvent) {
+        const isWithinDedupeWindow = capturedAt - existingEvent.capturedAt < DEDUPE_WINDOW_MS;
+
+        if (isWithinDedupeWindow) {
+          existingEvent.occurrenceCount += 1;
+
+          return;
+        }
+
+        // A throttled timer can leave an expired event pending. Its completed window must be
+        // submitted before this fingerprint is replaced with a new event and a new window.
+        this.pendingEvents.delete(fingerprint);
+        this.submit(existingEvent);
+      }
+
+      const event: UnhandledExceptionEvent = {
+        schemaVersion: 1,
+        capturedAt,
+        eventId: uuid.v4(),
+        occurrenceCount: 1,
+        common: {
+          appName: this.webex.config?.appName ?? this.webex.config?.sdkType ?? 'webex-js-sdk',
+          appVersion: this.webex.config?.appVersion,
+          runtime: 'browser',
+          sdkVersion: this.webex.version,
+        },
+        error: {...error, fingerprint},
+      };
+
+      this.addMetadata(event);
+      this.pendingEvents.set(fingerprint, event);
+
+      if (this.flushTimer === undefined) {
+        this.flushTimer = safeSetTimeout(() => this.flush(), DEDUPE_WINDOW_MS);
+      }
+    } catch {
+      logTelemetryFailure(this.webex, 'Failed to capture an exception.');
+    }
+  }
+
+  private addMetadata(event: UnhandledExceptionEvent): void {
+    const getMetadata = this.webex.config?.metrics?.unhandledExceptionTelemetry?.getMetadata;
+
+    if (!getMetadata) {
+      return;
+    }
+
+    try {
+      const metadata = getMetadata();
+
+      if (metadata === undefined) {
+        return;
+      }
+
+      const serializedMetadata = JSON.stringify(metadata);
+
+      if (serializedMetadata === undefined || serializedMetadata.length > MAX_METADATA_LENGTH) {
+        event.metadataCaptureStatus =
+          serializedMetadata === undefined ? 'invalid_type' : 'too_large';
+
+        return;
+      }
+
+      const parsedMetadata = JSON.parse(serializedMetadata);
+
+      if (
+        parsedMetadata === null ||
+        typeof parsedMetadata !== 'object' ||
+        Array.isArray(parsedMetadata)
+      ) {
+        event.metadataCaptureStatus = 'invalid_type';
+
+        return;
+      }
+
+      event.metadata = parsedMetadata;
+    } catch {
+      event.metadataCaptureStatus = 'provider_error';
+    }
+  }
+
+  private flush(): void {
+    const now = new Date().getTime();
+    let nextFlushInMs: number | undefined;
+
+    this.clearFlushTimer();
+    this.pendingEvents.forEach((event, fingerprint) => {
+      const remainingWindowMs = DEDUPE_WINDOW_MS - (now - event.capturedAt);
+
+      if (remainingWindowMs <= 0) {
+        this.pendingEvents.delete(fingerprint);
+        this.submit(event);
+
+        return;
+      }
+
+      nextFlushInMs = Math.min(nextFlushInMs ?? remainingWindowMs, remainingWindowMs);
+    });
+
+    if (nextFlushInMs !== undefined) {
+      this.flushTimer = safeSetTimeout(() => this.flush(), nextFlushInMs);
+    }
+  }
+
+  private submit(event: UnhandledExceptionEvent): void {
+    const submitClientMetrics = this.webex.internal?.metrics?.submitClientMetrics;
+
+    if (!submitClientMetrics) {
+      logTelemetryFailure(this.webex, 'submitClientMetrics is unavailable.');
+
+      return;
+    }
+
+    try {
+      Promise.resolve(
+        submitClientMetrics.call(
+          this.webex.internal?.metrics,
+          UNHANDLED_EXCEPTION_METRIC_NAME,
+          {
+            tags: {
+              app_name: event.common.appName,
+              exception_kind: event.error.kind,
+              runtime: event.common.runtime,
+            },
+            fields: {
+              captured_at: event.capturedAt,
+              error_fingerprint: event.error.fingerprint,
+              error_name: event.error.name,
+              event_id: event.eventId,
+              occurrence_count: event.occurrenceCount,
+            },
+            eventPayload: event,
+          },
+          this.webex.canAuthorize === true ? undefined : this.preLoginId
+        )
+      ).catch(() => {
+        logTelemetryFailure(this.webex, 'Failed to submit exception telemetry.');
+      });
+    } catch {
+      logTelemetryFailure(this.webex, 'Failed to submit exception telemetry.');
+    }
+  }
+
+  private clearFlushTimer(): void {
+    if (this.flushTimer !== undefined) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = undefined;
+    }
+  }
+}
+
+let activeTelemetry: UnhandledExceptionTelemetry | undefined;
+
+/**
+ * Starts browser exception telemetry after SDK readiness.
+ * @param webex Initialized SDK instance.
+ * @returns {void}
+ */
+export function startUnhandledExceptionTelemetry(webex: WebexForUnhandledExceptionTelemetry): void {
+  const shouldStart =
+    webex.config?.metrics?.unhandledExceptionTelemetry?.enabled === true &&
+    typeof window !== 'undefined' &&
+    typeof window.addEventListener === 'function';
+
+  activeTelemetry?.stop(shouldStart);
+  activeTelemetry = undefined;
+
+  if (!shouldStart) {
+    return;
+  }
+
+  try {
+    activeTelemetry = new UnhandledExceptionTelemetry(webex, window);
+  } catch {
+    logTelemetryFailure(webex, 'Failed to start exception telemetry.');
+  }
+}

package/src/unhandled-exception-telemetry/utils.ts

@@ -0,0 +1,101 @@
+/* eslint-disable require-jsdoc */
+
+const MAX_RESOURCE_URL_LENGTH = 2_048;
+
+export function truncate(value: string | undefined, maxLength: number): string | undefined {
+  return value?.slice(0, maxLength);
+}
+
+export function removeUrlDetails(value: unknown): string | undefined {
+  if (typeof value !== 'string' || value.length === 0) {
+    return undefined;
+  }
+
+  const withoutQueryOrFragment = value.split(/[?#]/, 1)[0];
+
+  // Strip URL userinfo from the authority. For example,
+  // https://userinfo@host/path becomes https://host/path.
+  return withoutQueryOrFragment.replace(/^((?:[a-z][a-z0-9+.-]*:)?\/\/)[^/?#]*@/i, '$1');
+}
+
+// Keep HTTP(S) and relative resource URLs, remove credentials/query/fragment details, and cap them.
+// For example, https://host/app.js?token=x becomes https://host/app.js, while
+// data:image/svg+xml,<svg>...</svg> is rejected because its scheme is not HTTP(S).
+export function sanitizeResourceUrl(value: unknown): string | undefined {
+  if (typeof value !== 'string' || value.length === 0) {
+    return undefined;
+  }
+
+  const url = value.trim();
+  const scheme = /^([a-z][a-z0-9+.-]*):/i.exec(url)?.[1]?.toLowerCase();
+
+  if (scheme && scheme !== 'http' && scheme !== 'https') {
+    return undefined;
+  }
+
+  return truncate(removeUrlDetails(url), MAX_RESOURCE_URL_LENGTH);
+}
+
+export function removeUrlDetailsFromText(value: string | undefined): string | undefined {
+  // Redact non-HTTP(S) schemes and strip credentials, queries, and fragments from other URLs.
+  // Examples: data:text/plain,secret -> [redacted-url], https://host/api?token=x ->
+  // https://host/api, api/messages?token=x -> api/messages, and GET app.js?token=x -> GET app.js.
+  return (
+    value
+      // Handles root and dot-relative paths such as /api?token=x and ../app.js#fragment.
+      // These run before the scheme matcher so query values such as x:10 are not treated as URLs.
+      ?.replace(
+        /(^|[\s("'=[{])((?:\/|\.\.?\/)[^\s)"'\]}]+)/g,
+        (_, prefix, url) => `${prefix}${removeUrlDetails(url) ?? url}`
+      )
+      .replace(
+        // Handles bare paths with a slash or file extension, such as api/messages?x=1 or app.js#x.
+        /(^|[\s("'=[{])((?:(?:[a-z0-9._~%-]+\/)+(?:[a-z0-9._~%-]+)?|[a-z0-9._~%-]+\.[a-z0-9._~%-]+)[?#][^\s)"'\]}]+)/gi,
+        (_, prefix, url) => `${prefix}${removeUrlDetails(url) ?? url}`
+      )
+      .replace(
+        // Handles extensionless single-segment paths after an HTTP method, such as GET api?token=x.
+        /\b(DELETE|GET|HEAD|OPTIONS|PATCH|POST|PUT)(\s+)([a-z0-9._~%-]+[?#][^\s)"'\]}]+)/gi,
+        (_, method, spacing, url) => `${method}${spacing}${removeUrlDetails(url) ?? url}`
+      )
+      .replace(
+        // Handles URLs with a scheme, including assigned values such as url=https://host/path?x=1.
+        // HTTP(S) details are stripped; data:, blob:, and other schemes are fully redacted.
+        /(^|[\s("'=[{,;])(([a-z][a-z0-9+.-]*):[^\s)"'\]}]+)/gi,
+        (_, prefix, url, scheme) =>
+          `${prefix}${
+            ['http', 'https'].includes(scheme.toLowerCase())
+              ? removeUrlDetails(url) ?? url
+              : '[redacted-url]'
+          }`
+      )
+  );
+}
+
+export function createFingerprint(value: string): string {
+  // DJB2-style hash: multiply by 33, add each UTF-16 code unit, and constrain the result to 32 bits.
+  // It provides a small stable deduplication key; it is not intended for cryptographic use.
+  let hash = 5381;
+
+  for (let index = 0; index < value.length; index += 1) {
+    hash = (hash * 33 + value.charCodeAt(index)) % 4_294_967_296;
+  }
+
+  return hash.toString(16).padStart(8, '0');
+}
+
+export function stringifyReason(reason: unknown): string {
+  if (typeof reason === 'string') {
+    return reason;
+  }
+
+  try {
+    return JSON.stringify(reason) ?? String(reason);
+  } catch {
+    try {
+      return String(reason);
+    } catch {
+      return 'Unserializable rejection reason';
+    }
+  }
+}

package/test/unit/spec/automated-user.ts

@@ -0,0 +1,43 @@
+import {assert} from '@webex/test-helper-chai';
+
+import {isAutomatedUser, isAutomatedUserAgent} from '../../../src/automated-user';
+
+describe('automated user detection', () => {
+  [
+    {userAgent: 'SkypeUriPreview', expected: true},
+    {userAgent: 'skypeuripreview', expected: true},
+    {userAgent: 'Mozilla/5.0 (compatible; SkypeUriPreview/0.1)', expected: true},
+    {userAgent: 'Googlebot/2.1 (+http://www.google.com/bot.html)', expected: true},
+    {
+      userAgent:
+        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/126.0.0.0 Safari/537.36',
+      expected: false,
+    },
+    {userAgent: undefined, expected: false},
+  ].forEach(({userAgent, expected}) => {
+    it(`returns ${expected} for ${userAgent || 'an undefined user agent'}`, () => {
+      assert.equal(isAutomatedUserAgent(userAgent), expected);
+    });
+  });
+
+  it('returns the cached classification when navigator changes', () => {
+    const cachedResult = isAutomatedUser();
+    const originalDescriptor = Object.getOwnPropertyDescriptor(global, 'navigator');
+
+    Object.defineProperty(global, 'navigator', {
+      value: cachedResult
+        ? {userAgent: 'Mozilla/5.0', webdriver: false}
+        : {userAgent: 'SkypeUriPreview', webdriver: true},
+      configurable: true,
+      writable: true,
+    });
+
+    assert.equal(isAutomatedUser(), cachedResult);
+
+    if (originalDescriptor) {
+      Object.defineProperty(global, 'navigator', originalDescriptor);
+    } else {
+      delete (global as any).navigator;
+    }
+  });
+});

package/test/unit/spec/batcher.js

@@ -177,6 +177,49 @@ describe('plugin-metrics', () => {
               assert.lengthOf(webex.internal.metrics.batcher.queue, 0);
             });
         });
+
+        it('rejects the deferred without reenqueuing when batcherRetryOnNetworkError is false', () => {
+          webex.config.metrics = {...config.metrics, batcherRetryOnNetworkError: false};
+
+          webex.request = function () {
+            // noop
+          };
+
+          sinon.stub(webex, 'request').callsFake((options) => {
+            options.headers = {
+              trackingid: 'test-no-retry',
+            };
+
+            return Promise.reject(
+              new WebexHttpError.NetworkOrCORSError({
+                statusCode: 0,
+                options,
+              })
+            );
+          });
+
+          const promise = webex.internal.metrics.batcher.request({
+            key: 'testMetric',
+          });
+
+          return promiseTick(50)
+            .then(() => assert.lengthOf(webex.internal.metrics.batcher.queue, 1))
+            .then(() => clock.tick(config.metrics.batcherWait))
+            .then(() => assert.calledOnce(webex.request))
+            .then(() => promiseTick(50))
+            .then(() =>
+              promise.then(
+                () => {
+                  assert.fail('promise should have been rejected');
+                },
+                (reason) => {
+                  assert.instanceOf(reason, WebexHttpError.NetworkOrCORSError);
+                  assert.lengthOf(webex.internal.metrics.batcher.queue, 0);
+                  assert.calledOnce(webex.request);
+                }
+              )
+            );
+        });
       });
     });
   });

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

@@ -142,9 +142,7 @@ describe('plugin-metrics', () => {
           webex.internal.newMetrics.callDiagnosticLatencies.getDiffBetweenTimestamps = sinon
             .stub()
             .returns(10);
-          webex.internal.newMetrics.callDiagnosticLatencies.getU2CTime = sinon
-            .stub()
-            .returns(20);
+          webex.internal.newMetrics.callDiagnosticLatencies.getU2CTime = sinon.stub().returns(20);
           webex.internal.newMetrics.callDiagnosticLatencies.getReachabilityClustersReqResp = sinon
             .stub()
             .returns(10);
@@ -165,7 +163,7 @@ describe('plugin-metrics', () => {
               registerWDMDeviceJMT: 10,
               showInterstitialTime: 10,
               getU2CTime: 20,
-              getReachabilityClustersReqResp: 10
+              getReachabilityClustersReqResp: 10,
             },
           });
           assert.lengthOf(
@@ -189,12 +187,17 @@ describe('plugin-metrics', () => {
           webex.internal.newMetrics.callDiagnosticLatencies.getDownloadTimeJMT = sinon
             .stub()
             .returns(100);
-          webex.internal.newMetrics.callDiagnosticLatencies.getClickToInterstitialWithUserDelay = sinon
-            .stub()
-            .returns(43);
+          webex.internal.newMetrics.callDiagnosticLatencies.getClickToInterstitialWithUserDelay =
+            sinon.stub().returns(43);
           webex.internal.newMetrics.callDiagnosticLatencies.getTotalJMTWithUserDelay = sinon
             .stub()
             .returns(64);
+          webex.internal.newMetrics.callDiagnosticLatencies.getInterstitialToJoinOK = sinon
+            .stub()
+            .returns(10);
+          webex.internal.newMetrics.callDiagnosticLatencies.getTotalJMT = sinon
+            .stub()
+            .returns(20);
           const promise = webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
             //@ts-ignore
             {event: {name: 'client.locus.join.response'}}
@@ -346,9 +349,15 @@ describe('plugin-metrics', () => {
           webex.internal.newMetrics.callDiagnosticLatencies.getInterstitialToJoinOK = sinon
             .stub()
             .returns(7);
-            webex.internal.newMetrics.callDiagnosticLatencies.getStayLobbyTime = sinon
+          webex.internal.newMetrics.callDiagnosticLatencies.getStayLobbyTime = sinon
+            .stub()
+            .returns(1);
+          webex.internal.newMetrics.callDiagnosticLatencies.getStayLobbyTimeCappedBy = sinon
             .stub()
             .returns(1);
+          webex.internal.newMetrics.callDiagnosticLatencies.getTotalMediaJMT = sinon
+            .stub()
+            .returns(44);
           webex.internal.newMetrics.callDiagnosticLatencies.getTotalMediaJMTWithUserDelay = sinon
             .stub()
             .returns(43);
@@ -369,10 +378,9 @@ describe('plugin-metrics', () => {
           assert.deepEqual(webex.request.getCalls()[0].args[0].body.metrics[0].eventPayload.event, {
             name: 'client.media-engine.ready',
             joinTimes: {
-              totalMediaJMT: 61,
+              totalMediaJMT: 44,
               interstitialToMediaOKJMT: 22,
-              callInitMediaEngineReady: 10,
-              stayLobbyTime: 1,
+              callInitMediaEngineReady: 22,
               totalMediaJMTWithUserDelay: 43,
               totalJMTWithUserDelay: 64,
             },
@@ -382,6 +390,34 @@ describe('plugin-metrics', () => {
             0
           );
         });
+
+        it('appends the correct join times to the request for client.lobby.exited', async () => {
+          webex.internal.newMetrics.callDiagnosticLatencies.getStayLobbyTime = sinon
+            .stub()
+            .returns(10);
+
+          const promise = webex.internal.newMetrics.callDiagnosticMetrics.submitToCallDiagnostics(
+            //@ts-ignore
+            {event: {name: 'client.lobby.exited'}}
+          );
+          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, {
+            name: 'client.lobby.exited',
+            joinTimes: {
+              stayLobbyTime: 10,
+            },
+          });
+          assert.lengthOf(
+            webex.internal.newMetrics.callDiagnosticMetrics.callDiagnosticEventsBatcher.queue,
+            0
+          );
+        });
       });
 
       describe('when the request fails', () => {