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

package/src/new-metrics.ts

@@ -0,0 +1,317 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable class-methods-use-this */
+/* eslint-disable valid-jsdoc */
+
+// @ts-ignore
+import {WebexPlugin} from '@webex/webex-core';
+
+import CallDiagnosticMetrics from './call-diagnostic/call-diagnostic-metrics';
+import {
+  RecursivePartial,
+  ClientEvent,
+  FeatureEvent,
+  BehavioralEvent,
+  OperationalEvent,
+  MediaQualityEvent,
+  InternalEvent,
+  SubmitClientEventOptions,
+} from './metrics.types';
+import CallDiagnosticLatencies from './call-diagnostic/call-diagnostic-metrics-latencies';
+import {setMetricTimings} from './call-diagnostic/call-diagnostic-metrics.util';
+import {generateCommonErrorMetadata} from './utils';
+
+/**
+ * Metrics plugin to centralize all types of metrics.
+ * @class
+ */
+class Metrics extends WebexPlugin {
+  // eslint-disable-next-line no-use-before-define
+  static instance: Metrics;
+
+  // Call Diagnostic latencies
+  callDiagnosticLatencies: CallDiagnosticLatencies;
+  // Helper classes to handle the different types of metrics
+  callDiagnosticMetrics: CallDiagnosticMetrics;
+
+  /**
+   * Constructor
+   * @param args
+   * @constructor
+   * @private
+   * @returns
+   */
+  constructor(...args) {
+    super(...args);
+
+    this.onReady();
+  }
+
+  /**
+   * On Ready
+   */
+  private onReady() {
+    // @ts-ignore
+    this.webex.once('ready', () => {
+      // @ts-ignore
+      this.callDiagnosticMetrics = new CallDiagnosticMetrics({}, {parent: this.webex});
+      // @ts-ignore
+      this.callDiagnosticLatencies = new CallDiagnosticLatencies({}, {parent: this.webex});
+    });
+  }
+
+  /**
+   * Used for internal purposes only
+   * @param args
+   */
+  submitInternalEvent({
+    name,
+    payload,
+    options,
+  }: {
+    name: InternalEvent['name'];
+    payload?: RecursivePartial<InternalEvent['payload']>;
+    options?: any;
+  }) {
+    if (name === 'internal.reset.join.latencies') {
+      this.callDiagnosticLatencies.clearTimestamps();
+    } else {
+      this.callDiagnosticLatencies.saveTimestamp({key: name});
+    }
+  }
+
+  /**
+   * Behavioral event
+   * @param args
+   */
+  submitBehavioralEvent({
+    name,
+    payload,
+    options,
+  }: {
+    name: BehavioralEvent['name'];
+    payload?: RecursivePartial<BehavioralEvent['payload']>;
+    options?: any;
+  }) {
+    this.callDiagnosticLatencies.saveTimestamp({key: name});
+    throw new Error('Not implemented.');
+  }
+
+  /**
+   * Operational event
+   * @param args
+   */
+  submitOperationalEvent({
+    name,
+    payload,
+    options,
+  }: {
+    name: OperationalEvent['name'];
+    payload?: RecursivePartial<OperationalEvent['payload']>;
+    options?: any;
+  }) {
+    throw new Error('Not implemented.');
+  }
+
+  /**
+   * Call Analyzer: Media Quality Event
+   * @param args
+   */
+  submitMQE({
+    name,
+    payload,
+    options,
+  }: {
+    name: MediaQualityEvent['name'];
+    payload: RecursivePartial<MediaQualityEvent['payload']> & {
+      intervals: MediaQualityEvent['payload']['intervals'];
+    };
+    options: any;
+  }) {
+    this.callDiagnosticLatencies.saveTimestamp({key: name});
+    this.callDiagnosticMetrics.submitMQE({name, payload, options});
+  }
+
+  /**
+   * Call Analyzer: Feature Usage Event
+   * @param args
+   */
+  submitFeatureEvent({
+    name,
+    payload,
+    options,
+  }: {
+    name: FeatureEvent['name'];
+    payload?: RecursivePartial<FeatureEvent['payload']>;
+    options: any;
+  }) {
+    throw new Error('Not implemented.');
+  }
+
+  /**
+   * Call Analyzer: Client Event
+   * @public
+   * @param args
+   */
+  public submitClientEvent({
+    name,
+    payload,
+    options,
+  }: {
+    name: ClientEvent['name'];
+    payload?: RecursivePartial<ClientEvent['payload']>;
+    options?: SubmitClientEventOptions;
+  }): Promise<any> {
+    if (!this.callDiagnosticLatencies || !this.callDiagnosticMetrics) {
+      // @ts-ignore
+      this.webex.logger.log(
+        `NewMetrics: @submitClientEvent. Attempted to submit before webex.ready. Event name: ${name}`
+      );
+
+      return Promise.resolve();
+    }
+    this.callDiagnosticLatencies.saveTimestamp({
+      key: name,
+      options: {meetingId: options?.meetingId},
+    });
+
+    return this.callDiagnosticMetrics.submitClientEvent({name, payload, options});
+  }
+
+  /**
+   * Submit a pre-login metric to clientmetrics
+   * @public
+   * @param payload
+   * @param preLoginId - pre-login ID of user
+   * @returns
+   */
+  public postPreLoginMetric(payload: any, preLoginId: string): Promise<any> {
+    // @ts-ignore
+    return this.webex
+      .request({
+        method: 'POST',
+        api: 'metrics',
+        resource: 'clientmetrics-prelogin',
+        headers: {
+          authorization: false,
+          'x-prelogin-userid': preLoginId,
+        },
+        body: {
+          metrics: [payload],
+        },
+      })
+      .then((res) => {
+        // @ts-ignore
+        this.webex.logger.log(`NewMetrics: @postPreLoginMetric. Request successful:`, res);
+
+        return res;
+      })
+      .catch((err) => {
+        // @ts-ignore
+        this.logger.error(
+          `NewMetrics: @postPreLoginMetric. Request failed:`,
+          `err: ${generateCommonErrorMetadata(err)}`
+        );
+
+        return Promise.reject(err);
+      });
+  }
+
+  /**
+   * Issue request to alias a user's pre-login ID with their CI UUID
+   * @param {string} preLoginId
+   * @returns {Object} HttpResponse object
+   */
+  public clientMetricsAliasUser(preLoginId: string) {
+    // @ts-ignore
+    return this.webex
+      .request({
+        method: 'POST',
+        api: 'metrics',
+        resource: 'clientmetrics',
+        headers: {
+          'x-prelogin-userid': preLoginId,
+        },
+        body: {},
+        qs: {
+          alias: true,
+        },
+      })
+      .then((res) => {
+        // @ts-ignore
+        this.webex.logger.log(`NewMetrics: @clientMetricsAliasUser. Request successful:`, res);
+
+        return res;
+      })
+      .catch((err) => {
+        // @ts-ignore
+        this.logger.error(
+          `NewMetrics: @clientMetricsAliasUser. Request failed:`,
+          `err: ${generateCommonErrorMetadata(err)}`
+        );
+
+        return Promise.reject(err);
+      });
+  }
+
+  /**
+   * Returns a promise that will resolve to fetch options for submitting a metric.
+   *
+   * This is to support quickly submitting metrics when the browser/tab is closing.
+   * Calling submitClientEvent will not work because there some async steps that will
+   * not complete before the browser is closed.  Instead, we pre-gather all the
+   * information/options needed for the request(s), and then simply and quickly
+   * fire the fetch(es) when beforeUnload is triggered.
+   *
+   * We must use fetch instead of request because fetch has a keepalive option that
+   * allows the request it to outlive the page.
+   *
+   * Note: the timings values will be wrong, but setMetricTimingsAndFetch() will
+   * properly adjust them before submitting.
+   *
+   * @public
+   * @param {Object} arg
+   * @param {String} arg.name - event name
+   * @param {Object} arg.payload - event payload
+   * @param {Object} arg.options - other options
+   * @returns {Promise} promise that resolves to options to be used with fetch
+   */
+  public async buildClientEventFetchRequestOptions({
+    name,
+    payload,
+    options,
+  }: {
+    name: ClientEvent['name'];
+    payload?: RecursivePartial<ClientEvent['payload']>;
+    options?: SubmitClientEventOptions;
+  }): Promise<any> {
+    return this.callDiagnosticMetrics.buildClientEventFetchRequestOptions({
+      name,
+      payload,
+      options,
+    });
+  }
+
+  /**
+   * Submits a metric from pre-built request options via the fetch API. Updates
+   * the "$timings" and "originTime" values to Date.now() since the existing times
+   * were set when the options were built (not submitted).
+
+   * @param {any} options - the pre-built request options for submitting a metric
+   * @returns {Promise} promise that resolves to the response object
+   */
+  public setMetricTimingsAndFetch(options: any): Promise<any> {
+    // @ts-ignore
+    return this.webex.setTimingsAndFetch(setMetricTimings(options));
+  }
+
+  /**
+   * Returns true if the specified serviceErrorCode maps to an expected error.
+   * @param {number} serviceErrorCode the service error code
+   * @returns {boolean}
+   */
+  public isServiceErrorExpected(serviceErrorCode: number): boolean {
+    return this.callDiagnosticMetrics.isServiceErrorExpected(serviceErrorCode);
+  }
+}
+
+export default Metrics;

package/src/utils.ts

@@ -0,0 +1,17 @@
+/* eslint-disable import/prefer-default-export */
+/**
+ * Generates common metadata for errors
+ * @param {any} error
+ * @returns {object}
+ */
+export const generateCommonErrorMetadata = (error) => {
+  if (error instanceof Error) {
+    return JSON.stringify({
+      message: error?.message,
+      name: error?.name,
+      stack: error?.stack,
+    });
+  }
+
+  return error;
+};

package/test/unit/spec/batcher.js

@@ -27,8 +27,8 @@ describe('plugin-metrics', () => {
     beforeEach(() => {
       webex = new MockWebex({
         children: {
-          metrics: Metrics
-        }
+          metrics: Metrics,
+        },
       });
 
       webex.config.metrics = config.metrics;
@@ -37,7 +37,8 @@ describe('plugin-metrics', () => {
         return Promise.resolve({
           statusCode: 204,
           body: undefined,
-          options
+          waitForServiceTimeout: 15,
+          options,
         });
       };
       sinon.spy(webex, 'request');
@@ -58,9 +59,10 @@ describe('plugin-metrics', () => {
         it('clears the queue', () => {
           clock.uninstall();
 
-          return webex.internal.metrics.batcher.request({
-            key: 'testMetric'
-          })
+          return webex.internal.metrics.batcher
+            .request({
+              key: 'testMetric',
+            })
             .then(() => {
               assert.calledOnce(webex.request);
               assert.lengthOf(webex.internal.metrics.batcher.queue, 0);
@@ -80,26 +82,29 @@ describe('plugin-metrics', () => {
 
           sinon.stub(webex, 'request').callsFake((options) => {
             options.headers = {
-              trackingid: count
+              trackingid: count,
             };
 
             count += 1;
             if (count < 9) {
-              return Promise.reject(new WebexHttpError.NetworkOrCORSError({
-                statusCode: 0,
-                options
-              }));
+              return Promise.reject(
+                new WebexHttpError.NetworkOrCORSError({
+                  statusCode: 0,
+                  options,
+                })
+              );
             }
 
             return Promise.resolve({
               statusCode: 204,
               body: undefined,
-              options
+              waitForServiceTimeout: 15,
+              options,
             });
           });
 
           const promise = webex.internal.metrics.batcher.request({
-            key: 'testMetric'
+            key: 'testMetric',
           });
 
           return promiseTick(50)
@@ -159,8 +164,16 @@ describe('plugin-metrics', () => {
             .then(() => assert.lengthOf(webex.internal.metrics.batcher.queue, 0))
             .then(() => promise)
             .then(() => {
-              assert.lengthOf(webex.request.args[1][0].body.metrics, 1, 'Reenqueuing the metric once did not increase the number of metrics to be submitted');
-              assert.lengthOf(webex.request.args[2][0].body.metrics, 1, 'Reenqueuing the metric twice did not increase the number of metrics to be submitted');
+              assert.lengthOf(
+                webex.request.args[1][0].body.metrics,
+                1,
+                'Reenqueuing the metric once did not increase the number of metrics to be submitted'
+              );
+              assert.lengthOf(
+                webex.request.args[2][0].body.metrics,
+                1,
+                'Reenqueuing the metric twice did not increase the number of metrics to be submitted'
+              );
               assert.lengthOf(webex.internal.metrics.batcher.queue, 0);
             });
         });