@webex/internal-plugin-metrics 3.11.0 → 3.12.0-llmrefactor.1

package/src/prelogin-metrics.ts

@@ -0,0 +1,94 @@
+import GenericMetrics from './generic-metrics';
+import {BusinessEvent, EventPayload} from './metrics.types';
+import PreLoginMetricsBatcher from './prelogin-metrics-batcher';
+
+/**
+ * @description Util class to handle PreLogin Metrics
+ * @export
+ * @class PreLoginMetrics
+ */
+export default class PreLoginMetrics extends GenericMetrics {
+  private preLoginMetricsBatcher: typeof PreLoginMetricsBatcher;
+
+  /**
+   * Constructor
+   * @param {PreLoginMetricsBatcher} preLoginMetricsBatcher - Pre-login metrics batcher
+   * @param {any} attrs - Attributes
+   * @param {any} options - Options
+   * @constructor
+   */
+  constructor(
+    preLoginMetricsBatcher: typeof PreLoginMetricsBatcher,
+    attrs: any = {},
+    options: {parent?: any} = {}
+  ) {
+    super(attrs, options);
+    this.preLoginMetricsBatcher = preLoginMetricsBatcher;
+  }
+
+  /**
+   * Submit a business metric to our metrics endpoint.
+   * Routes to the correct table with the correct schema payload by table.
+   * @see https://confluence-eng-gpk2.cisco.com/conf/display/WAP/Business+metrics++-%3E+ROMA
+   * @param {Object} options - The options object
+   * @param {string} options.name - Name of the metric
+   * @param {string} options.preLoginId - ID to identify pre-login user
+   * @param {EventPayload} options.payload - User payload of the metric
+   * @param {EventPayload} [options.metadata] - Optional metadata to include outside of eventPayload.value
+   * @returns {Promise<void>} Promise that resolves when the metric is submitted
+   */
+  public submitPreLoginEvent({
+    name,
+    preLoginId,
+    payload,
+    metadata,
+  }: {
+    name: string;
+    preLoginId: string;
+    payload: EventPayload;
+    metadata?: EventPayload;
+  }): Promise<void> {
+    if (!metadata) {
+      metadata = {};
+    }
+    if (!metadata.appType) {
+      metadata.appType = 'Web Client';
+    }
+
+    const finalEvent = this.buildEvent(name, preLoginId, payload, metadata);
+
+    this.preLoginMetricsBatcher.savePreLoginId(preLoginId);
+
+    return this.preLoginMetricsBatcher.request(finalEvent);
+  }
+
+  /**
+   * Builds a formatted event object for metrics submission.
+   * @param {string} metricName - Metric name
+   * @param {string} preLoginId - Pre-login user identifier
+   * @param {EventPayload} payload - Metric payload data
+   * @param {EventPayload} metadata - Additional metadata to include in the event
+   * @returns {object} Formatted metrics event object with type, eventPayload, and timestamp
+   */
+  private buildEvent(
+    metricName: string,
+    preLoginId: string,
+    payload: EventPayload,
+    metadata: EventPayload
+  ): BusinessEvent {
+    return {
+      type: ['business'],
+      eventPayload: {
+        metricName,
+        browserDetails: this.getBrowserDetails(),
+        context: this.getContext(),
+        timestamp: new Date().getTime(),
+        value: {
+          preLoginId,
+          ...metadata,
+          ...payload,
+        },
+      },
+    };
+  }
+}

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', () => {