@webex/internal-plugin-metrics 3.0.0-bnr.4 → 3.0.0

package/dist/types/call-diagnostic/config.d.ts

@@ -0,0 +1,178 @@
+import { ClientEventError, ClientSubServiceType } from '../metrics.types';
+export declare const CALL_DIAGNOSTIC_LOG_IDENTIFIER = "call-diagnostic-events -> ";
+export declare const AUTHENTICATION_FAILED_CODE = 1010;
+export declare const NETWORK_ERROR = 1026;
+export declare const NEW_LOCUS_ERROR_CLIENT_CODE = 4008;
+export declare const MEETING_INFO_LOOKUP_ERROR_CLIENT_CODE = 4100;
+export declare const UNKNOWN_ERROR = 9999;
+export declare const ICE_FAILURE_CLIENT_CODE = 2004;
+export declare const MISSING_ROAP_ANSWER_CLIENT_CODE = 2007;
+export declare const DTLS_HANDSHAKE_FAILED_CLIENT_CODE = 2008;
+export declare const ICE_FAILED_WITH_TURN_TLS_CLIENT_CODE = 2010;
+export declare const ICE_FAILED_WITHOUT_TURN_TLS_CLIENT_CODE = 2009;
+export declare const WBX_APP_API_URL = "wbxappapi";
+export declare const WEBEX_SUB_SERVICE_TYPES: Record<string, ClientSubServiceType>;
+export declare const BROWSER_MEDIA_ERROR_NAME_TO_CLIENT_ERROR_CODES_MAP: {
+    [x: string]: number;
+};
+export declare const SDP_OFFER_CREATION_ERROR_MAP: {
+    GENERAL: number;
+    SDP_MUNGE_MISSING_CODECS: number;
+};
+export declare const ERROR_DESCRIPTIONS: {
+    UNKNOWN_CALL_FAILURE: string;
+    LOCUS_RATE_LIMITED_INCOMING: string;
+    LOCUS_RATE_LIMITED_OUTGOING: string;
+    LOCUS_UNAVAILABLE: string;
+    LOCUS_CONFLICT: string;
+    TIMEOUT: string;
+    LOCUS_INVALID_SEQUENCE_HASH: string;
+    AUTHENTICATION_FAILED: string;
+    NETWORK_ERROR: string;
+    UPDATE_MEDIA_FAILED: string;
+    FAILED_TO_CONNECT_MEDIA: string;
+    MEDIA_ENGINE_LOST: string;
+    MEDIA_CONNECTION_LOST: string;
+    ICE_FAILURE: string;
+    MEDIA_ENGINE_HANG: string;
+    ICE_SERVER_REJECTED: string;
+    CALL_FULL: string;
+    ROOM_TOO_LARGE: string;
+    GUEST_ALREADY_ADDED: string;
+    LOCUS_USER_NOT_AUTHORISED: string;
+    CLOUDBERRY_UNAVAILABLE: string;
+    ROOM_TOO_LARGE_FREE_ACCOUNT: string;
+    MEETING_INACTIVE: string;
+    MEETING_LOCKED: string;
+    MEETING_TERMINATING: string;
+    MODERATOR_PIN_OR_GUEST_REQUIRED: string;
+    MODERATOR_PIN_OR_GUEST_PIN_REQUIRED: string;
+    MODERATOR_REQUIRED: string;
+    USER_NOT_MEMBER_OF_ROOM: string;
+    NEW_LOCUS_ERROR: string;
+    NETWORK_UNAVAILABLE: string;
+    MEETING_UNAVAILABLE: string;
+    MEETING_ID_INVALID: string;
+    MEETING_SITE_INVALID: string;
+    LOCUS_INVALID_JOINTIME: string;
+    LOBBY_EXPIRED: string;
+    MEDIA_CONNECTION_LOST_PAIRED: string;
+    PHONE_NUMBER_NOT_A_NUMBER: string;
+    PHONE_NUMBER_TOO_LONG: string;
+    INVALID_DIALABLE_KEY: string;
+    ONE_ON_ONE_TO_SELF_NOT_ALLOWED: string;
+    REMOVED_PARTICIPANT: string;
+    MEETING_LINK_NOT_FOUND: string;
+    PHONE_NUMBER_TOO_SHORT_AFTER_IDD: string;
+    INVALID_INVITEE_ADDRESS: string;
+    PMR_USER_ACCOUNT_LOCKED_OUT: string;
+    GUEST_FORBIDDEN: string;
+    PMR_ACCOUNT_SUSPENDED: string;
+    EMPTY_PHONE_NUMBER_OR_COUNTRY_CODE: string;
+    CONVERSATION_NOT_FOUND: string;
+    SIP_CALLEE_BUSY: string;
+    SIP_CALLEE_NOT_FOUND: string;
+    START_RECORDING_FAILED: string;
+    RECORDING_IN_PROGRESS_FAILED: string;
+    MEETING_INFO_LOOKUP_ERROR: string;
+    CALL_FULL_ADD_GUEST: string;
+    REQUIRE_WEBEX_LOGIN: string;
+    USER_NOT_ALLOWED_ACCESS_MEETING: string;
+    USER_NEEDS_ACTIVATION: string;
+    SIGN_UP_INVALID_EMAIL: string;
+    UNKNOWN_ERROR: string;
+    NO_MEDIA_FOUND: string;
+    STREAM_ERROR_NO_MEDIA: string;
+    CAMERA_PERMISSION_DENIED: string;
+    FRAUD_DETECTION: string;
+    E2EE_NOT_SUPPORTED: string;
+    LOCUS_LOBBY_FULL_CMR: string;
+    USER_NOT_INVITED_TO_JOIN: string;
+    MISSING_ROAP_ANSWER: string;
+    DTLS_HANDSHAKE_FAILED: string;
+    ICE_FAILED_WITHOUT_TURN_TLS: string;
+    ICE_FAILED_WITH_TURN_TLS: string;
+    SDP_OFFER_CREATION_ERROR: string;
+    SDP_OFFER_CREATION_ERROR_MISSING_CODEC: string;
+};
+export declare const SERVICE_ERROR_CODES_TO_CLIENT_ERROR_CODES_MAP: {
+    58400: number;
+    99002: number;
+    99009: number;
+    58500: number;
+    400001: number;
+    403004: number;
+    403028: number;
+    403032: number;
+    403034: number;
+    403036: number;
+    403038: number;
+    403040: number;
+    403041: number;
+    403047: number;
+    403408: number;
+    403043: number;
+    403048: number;
+    403049: number;
+    403100: number;
+    403101: number;
+    403102: number;
+    403103: number;
+    403104: number;
+    404001: number;
+    404006: number;
+    423001: number;
+    423005: number;
+    423006: number;
+    423010: number;
+    423012: number;
+    423013: number;
+    429005: number;
+    2403001: number;
+    2403002: number;
+    2403003: number;
+    2403004: number;
+    2403018: number;
+    2403019: number;
+    2423003: number;
+    2423004: number;
+    2423005: number;
+    2423006: number;
+    2423016: number;
+    2423017: number;
+    2423018: number;
+    2423012: number;
+    2423021: number;
+    2423007: number;
+    2403010: number;
+    2403014: number;
+    2403015: number;
+    2423010: number;
+    2400008: number;
+    2400011: number;
+    2400012: number;
+    2403007: number;
+    2401002: number;
+    2404002: number;
+    2400009: number;
+    2400025: number;
+    2423009: number;
+    2403022: number;
+    2423008: number;
+    2400006: number;
+    2400014: number;
+    2404001: number;
+    2403025: number;
+    2405001: number;
+    2409005: number;
+    2409062: number;
+    2423025: number;
+    100002: number;
+    100007: number;
+    100001: number;
+    100006: number;
+    100005: number;
+    100004: number;
+};
+export declare const CLIENT_ERROR_CODE_TO_ERROR_PAYLOAD: Record<number, Partial<ClientEventError>>;
+export declare const CALL_DIAGNOSTIC_EVENT_FAILED_TO_SEND = "js_sdk_call_diagnostic_event_failed_to_send";

package/dist/types/config.d.ts

@@ -12,7 +12,25 @@ declare namespace _default {
         const batcherMaxCalls: number;
         const batcherMaxWait: number;
         const batcherRetryPlateau: number;
+        const waitForServiceTimeout: number;
     }
     export { metrics_1 as metrics };
 }
 export default _default;
+export namespace OS_NAME {
+    const WINDOWS: string;
+    const MAC: string;
+    const IOS: string;
+    const ANDROID: string;
+    const CHROME: string;
+    const LINUX: string;
+    const OTHERS: string;
+}
+export const OSMap: {
+    'Chrome OS': string;
+    macOS: string;
+    Windows: string;
+    iOS: string;
+    Android: string;
+    Linux: string;
+};

package/dist/types/index.d.ts

@@ -1,3 +1,15 @@
-export { default } from "./metrics";
-export { config };
-import config from "./config";
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+import '@webex/internal-plugin-device';
+import config from './config';
+import NewMetrics from './new-metrics';
+import * as Utils from './utils';
+import { ClientEvent, ClientEventLeaveReason, SubmitBehavioralEvent, SubmitClientEvent, SubmitInternalEvent, SubmitOperationalEvent, SubmitMQE } from './metrics.types';
+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';
+export { default, getOSNameInternal } from './metrics';
+export { config, CALL_DIAGNOSTIC_CONFIG, NewMetrics, Utils, CallDiagnosticUtils, CallDiagnosticLatencies, CallDiagnosticMetrics, };
+export type { ClientEvent, ClientEventLeaveReason, SubmitBehavioralEvent, SubmitClientEvent, SubmitInternalEvent, SubmitMQE, SubmitOperationalEvent, };

package/dist/types/metrics.d.ts

@@ -1,2 +1,3 @@
+export function getOSNameInternal(): any;
 export default Metrics;
 declare const Metrics: any;

package/dist/types/metrics.types.d.ts

@@ -0,0 +1,105 @@
+import { ClientEvent as RawClientEvent, Event as RawEvent, MediaQualityEvent as RawMediaQualityEvent } from '@webex/event-dictionary-ts';
+export type Event = Omit<RawEvent, 'event'> & {
+    event: RawClientEvent | RawMediaQualityEvent;
+};
+export type ClientEventError = NonNullable<RawClientEvent['errors']>[0];
+export type EnvironmentType = NonNullable<RawEvent['origin']['environment']>;
+export type NewEnvironmentType = NonNullable<RawEvent['origin']['newEnvironment']>;
+export type ClientLaunchMethodType = NonNullable<RawEvent['origin']['clientInfo']>['clientLaunchMethod'];
+export type SubmitClientEventOptions = {
+    meetingId?: string;
+    mediaConnections?: any[];
+    rawError?: any;
+    correlationId?: string;
+    preLoginId?: string;
+    environment?: EnvironmentType;
+    newEnvironmentType?: NewEnvironmentType;
+    clientLaunchMethod?: ClientLaunchMethodType;
+    webexConferenceIdStr?: string;
+    globalMeetingId?: string;
+};
+export type SubmitMQEOptions = {
+    meetingId: string;
+    mediaConnections?: any[];
+    networkType?: Event['origin']['networkType'];
+    webexConferenceIdStr?: string;
+    globalMeetingId?: string;
+};
+export type InternalEvent = {
+    name: 'internal.client.meetinginfo.request' | 'internal.client.meetinginfo.response' | 'internal.register.device.request' | 'internal.register.device.response' | 'internal.reset.join.latencies' | 'internal.client.meeting.click.joinbutton' | 'internal.host.meeting.participant.admitted' | 'internal.client.meeting.interstitial-window.showed' | 'internal.client.interstitial-window.click.joinbutton' | 'internal.client.add-media.turn-discovery.start' | 'internal.client.add-media.turn-discovery.end';
+    payload?: never;
+    options?: never;
+};
+export interface ClientEvent {
+    name: RawClientEvent['name'];
+    payload?: RawClientEvent;
+    options?: SubmitClientEventOptions;
+}
+export interface BehavioralEvent {
+    name: 'host.meeting.participant.admitted' | 'sdk.media-flow.started';
+    payload?: never;
+    options?: never;
+}
+export interface OperationalEvent {
+    name: never;
+    payload?: never;
+    options?: never;
+}
+export interface FeatureEvent {
+    name: never;
+    payload?: never;
+    options?: never;
+}
+export interface MediaQualityEvent {
+    name: RawMediaQualityEvent['name'];
+    payload?: RawMediaQualityEvent;
+    options: SubmitMQEOptions;
+}
+export type RecursivePartial<T> = {
+    [P in keyof T]?: T[P] extends (infer U)[] ? RecursivePartial<U>[] : T[P] extends object ? RecursivePartial<T[P]> : T[P];
+};
+export type MetricEventNames = InternalEvent['name'] | ClientEvent['name'] | BehavioralEvent['name'] | OperationalEvent['name'] | FeatureEvent['name'] | MediaQualityEvent['name'];
+export type ClientInfo = NonNullable<RawEvent['origin']['clientInfo']>;
+export type ClientType = NonNullable<RawEvent['origin']['clientInfo']>['clientType'];
+export type SubClientType = NonNullable<RawEvent['origin']['clientInfo']>['subClientType'];
+export type NetworkType = NonNullable<RawEvent['origin']>['networkType'];
+export type ClientSubServiceType = ClientEvent['payload']['webexSubServiceType'];
+export type ClientEventPayload = RecursivePartial<ClientEvent['payload']>;
+export type ClientEventLeaveReason = ClientEvent['payload']['leaveReason'];
+export type ClientEventPayloadError = ClientEvent['payload']['errors'];
+export type MediaQualityEventAudioSetupDelayPayload = NonNullable<MediaQualityEvent['payload']>['audioSetupDelay'];
+export type MediaQualityEventVideoSetupDelayPayload = NonNullable<MediaQualityEvent['payload']>['videoSetupDelay'];
+export type SubmitMQEPayload = RecursivePartial<MediaQualityEvent['payload']> & {
+    intervals: NonNullable<MediaQualityEvent['payload']>['intervals'];
+};
+export type SubmitInternalEvent = (args: {
+    name: InternalEvent['name'];
+    payload?: RecursivePartial<InternalEvent['payload']>;
+    options?: any;
+}) => void;
+export type SubmitBehavioralEvent = (args: {
+    name: BehavioralEvent['name'];
+    payload?: RecursivePartial<BehavioralEvent['payload']>;
+    options?: any;
+}) => void;
+export type SubmitClientEvent = (args: {
+    name: ClientEvent['name'];
+    payload?: RecursivePartial<ClientEvent['payload']>;
+    options?: SubmitClientEventOptions;
+}) => Promise<any>;
+export type SubmitOperationalEvent = (args: {
+    name: OperationalEvent['name'];
+    payload?: RecursivePartial<OperationalEvent['payload']>;
+    options?: any;
+}) => void;
+export type SubmitMQE = (args: {
+    name: MediaQualityEvent['name'];
+    payload: SubmitMQEPayload;
+    options: any;
+}) => void;
+export type BuildClientEventFetchRequestOptions = (args: {
+    name: ClientEvent['name'];
+    payload?: RecursivePartial<ClientEvent['payload']>;
+    options?: SubmitClientEventOptions;
+}) => Promise<any>;
+export type PreComputedLatencies = 'internal.client.pageJMT' | 'internal.download.time' | 'internal.click.to.interstitial' | 'internal.call.init.join.req';

package/dist/types/new-metrics.d.ts

@@ -0,0 +1,131 @@
+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';
+/**
+ * Metrics plugin to centralize all types of metrics.
+ * @class
+ */
+declare class Metrics extends WebexPlugin {
+    static instance: Metrics;
+    callDiagnosticLatencies: CallDiagnosticLatencies;
+    callDiagnosticMetrics: CallDiagnosticMetrics;
+    /**
+     * Constructor
+     * @param args
+     * @constructor
+     * @private
+     * @returns
+     */
+    constructor(...args: any[]);
+    /**
+     * On Ready
+     */
+    private onReady;
+    /**
+     * Used for internal purposes only
+     * @param args
+     */
+    submitInternalEvent({ name, payload, options, }: {
+        name: InternalEvent['name'];
+        payload?: RecursivePartial<InternalEvent['payload']>;
+        options?: any;
+    }): void;
+    /**
+     * Behavioral event
+     * @param args
+     */
+    submitBehavioralEvent({ name, payload, options, }: {
+        name: BehavioralEvent['name'];
+        payload?: RecursivePartial<BehavioralEvent['payload']>;
+        options?: any;
+    }): void;
+    /**
+     * Operational event
+     * @param args
+     */
+    submitOperationalEvent({ name, payload, options, }: {
+        name: OperationalEvent['name'];
+        payload?: RecursivePartial<OperationalEvent['payload']>;
+        options?: any;
+    }): void;
+    /**
+     * Call Analyzer: Media Quality Event
+     * @param args
+     */
+    submitMQE({ name, payload, options, }: {
+        name: MediaQualityEvent['name'];
+        payload: RecursivePartial<MediaQualityEvent['payload']> & {
+            intervals: MediaQualityEvent['payload']['intervals'];
+        };
+        options: any;
+    }): void;
+    /**
+     * Call Analyzer: Feature Usage Event
+     * @param args
+     */
+    submitFeatureEvent({ name, payload, options, }: {
+        name: FeatureEvent['name'];
+        payload?: RecursivePartial<FeatureEvent['payload']>;
+        options: any;
+    }): void;
+    /**
+     * Call Analyzer: Client Event
+     * @public
+     * @param args
+     */
+    submitClientEvent({ name, payload, options, }: {
+        name: ClientEvent['name'];
+        payload?: RecursivePartial<ClientEvent['payload']>;
+        options?: SubmitClientEventOptions;
+    }): Promise<any>;
+    /**
+     * Issue request to alias a user's pre-login ID with their CI UUID
+     * @param {string} preLoginId
+     * @returns {Object} HttpResponse object
+     */
+    clientMetricsAliasUser(preLoginId: string): any;
+    /**
+     * 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
+     */
+    buildClientEventFetchRequestOptions({ name, payload, options, }: {
+        name: ClientEvent['name'];
+        payload?: RecursivePartial<ClientEvent['payload']>;
+        options?: SubmitClientEventOptions;
+    }): Promise<any>;
+    /**
+     * 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
+     */
+    setMetricTimingsAndFetch(options: any): Promise<any>;
+    /**
+     * Returns true if the specified serviceErrorCode maps to an expected error.
+     * @param {number} serviceErrorCode the service error code
+     * @returns {boolean}
+     */
+    isServiceErrorExpected(serviceErrorCode: number): boolean;
+}
+export default Metrics;

package/dist/types/prelogin-metrics-batcher.d.ts

@@ -0,0 +1,2 @@
+declare const PreLoginMetricsBatcher: any;
+export default PreLoginMetricsBatcher;

package/dist/types/utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generates common metadata for errors
+ * @param {any} error
+ * @returns {object}
+ */
+export declare const generateCommonErrorMetadata: (error: any) => any;

package/dist/utils.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
+var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault");
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateCommonErrorMetadata = void 0;
+var _stringify = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/json/stringify"));
+/* eslint-disable import/prefer-default-export */
+/**
+ * Generates common metadata for errors
+ * @param {any} error
+ * @returns {object}
+ */
+var generateCommonErrorMetadata = exports.generateCommonErrorMetadata = function generateCommonErrorMetadata(error) {
+  if (error instanceof Error) {
+    return (0, _stringify.default)({
+      message: error === null || error === void 0 ? void 0 : error.message,
+      name: error === null || error === void 0 ? void 0 : error.name,
+      stack: error === null || error === void 0 ? void 0 : error.stack
+    });
+  }
+  return error;
+};
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["generateCommonErrorMetadata","exports","error","Error","_stringify","default","message","name","stack"],"sources":["utils.ts"],"sourcesContent":["/* eslint-disable import/prefer-default-export */\n/**\n * Generates common metadata for errors\n * @param {any} error\n * @returns {object}\n */\nexport const generateCommonErrorMetadata = (error) => {\n  if (error instanceof Error) {\n    return JSON.stringify({\n      message: error?.message,\n      name: error?.name,\n      stack: error?.stack,\n    });\n  }\n\n  return error;\n};\n"],"mappings":";;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACO,IAAMA,2BAA2B,GAAAC,OAAA,CAAAD,2BAAA,GAAG,SAA9BA,2BAA2BA,CAAIE,KAAK,EAAK;EACpD,IAAIA,KAAK,YAAYC,KAAK,EAAE;IAC1B,OAAO,IAAAC,UAAA,CAAAC,OAAA,EAAe;MACpBC,OAAO,EAAEJ,KAAK,aAALA,KAAK,uBAALA,KAAK,CAAEI,OAAO;MACvBC,IAAI,EAAEL,KAAK,aAALA,KAAK,uBAALA,KAAK,CAAEK,IAAI;MACjBC,KAAK,EAAEN,KAAK,aAALA,KAAK,uBAALA,KAAK,CAAEM;IAChB,CAAC,CAAC;EACJ;EAEA,OAAON,KAAK;AACd,CAAC"}

package/jest.config.js

@@ -0,0 +1,3 @@
+const config = require('@webex/jest-config-legacy');
+
+module.exports = config;

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@webex/internal-plugin-metrics",
-  "version": "3.0.0-bnr.4",
   "description": "",
   "license": "MIT",
   "main": "dist/index.js",
   "devMain": "src/index.js",
+  "types": "dist/types/index.d.ts",
   "repository": {
     "type": "git",
     "url": "https://github.com/webex/webex-js-sdk.git",
@@ -20,16 +20,40 @@
     ]
   },
   "devDependencies": {
+    "@babel/core": "^7.17.10",
     "@sinonjs/fake-timers": "^6.0.1",
+    "@webex/babel-config-legacy": "0.0.0",
+    "@webex/eslint-config-legacy": "0.0.0",
+    "@webex/jest-config-legacy": "0.0.0",
+    "@webex/legacy-tools": "0.0.0",
+    "@webex/test-helper-chai": "3.0.0",
+    "@webex/test-helper-mocha": "3.0.0",
+    "@webex/test-helper-mock-webex": "3.0.0",
+    "@webex/test-helper-test-users": "3.0.0",
+    "eslint": "^8.24.0",
+    "prettier": "^2.7.1",
     "sinon": "^9.2.4"
   },
   "dependencies": {
-    "@webex/common": "workspace:^",
-    "@webex/common-timers": "workspace:^",
-    "@webex/internal-plugin-device": "workspace:^",
-    "@webex/internal-plugin-metrics": "workspace:^",
-    "@webex/test-helper-chai": "workspace:^",
-    "@webex/test-helper-mock-webex": "workspace:^",
-    "@webex/webex-core": "workspace:^"
-  }
-}
+    "@webex/common": "3.0.0",
+    "@webex/common-timers": "3.0.0",
+    "@webex/event-dictionary-ts": "^1.0.1329",
+    "@webex/internal-plugin-device": "3.0.0",
+    "@webex/internal-plugin-metrics": "3.0.0",
+    "@webex/test-helper-chai": "3.0.0",
+    "@webex/test-helper-mock-webex": "3.0.0",
+    "@webex/webex-core": "3.0.0",
+    "ip-anonymize": "^0.1.0",
+    "lodash": "^4.17.21",
+    "uuid": "^3.3.2"
+  },
+  "scripts": {
+    "build": " yarn run -T tsc --declaration true --declarationDir ./dist/types",
+    "build:src": "webex-legacy-tools build -dest \"./dist\" -src \"./src\" -js -ts -maps && yarn build",
+    "deploy:npm": "yarn npm publish",
+    "test": "yarn test:style && yarn test:unit && yarn test:integration && yarn test:browser",
+    "test:style": "eslint ./src/**/*.*",
+    "test:unit": "webex-legacy-tools test --unit --runner mocha"
+  },
+  "version": "3.0.0"
+}

package/process

@@ -0,0 +1 @@
+module.exports = {browser: true};

package/src/batcher.js

@@ -7,9 +7,18 @@ import {safeSetTimeout} from '@webex/common-timers';
 
 const sym = Symbol('metric id');
 
+/**
+ * @class
+ * @extends Batcher
+ * @memberof Metrics
+ */
 const MetricsBatcher = Batcher.extend({
   namespace: 'Metrics',
 
+  /**
+   * @param {any} item
+   * @returns {Promise<any>}
+   */
   prepareItem(item) {
     // Keep non-prod data out of metrics
     const env = process.env.NODE_ENV === 'production' ? null : 'TEST';
@@ -22,6 +31,10 @@ const MetricsBatcher = Batcher.extend({
     return Promise.resolve(item);
   },
 
+  /**
+   * @param {any[]} queue
+   * @returns {Promise<any[]>}
+   */
   prepareRequest(queue) {
     return Promise.resolve(
       queue.map((item) => {
@@ -32,6 +45,10 @@ const MetricsBatcher = Batcher.extend({
     );
   },
 
+  /**
+   * @param {any} payload
+   * @returns {Promise<any>}
+   */
   submitHttpRequest(payload) {
     return this.webex.request({
       method: 'POST',
@@ -40,13 +57,22 @@ const MetricsBatcher = Batcher.extend({
       body: {
         metrics: payload,
       },
+      waitForServiceTimeout: this.webex.config.metrics.waitForServiceTimeout,
     });
   },
 
+  /**
+   * @param {any} res
+   * @returns {Promise<any>}
+   */
   handleHttpSuccess(res) {
     return Promise.all(res.options.body.metrics.map((item) => this.acceptItem(item)));
   },
 
+  /**
+   * @param {any} reason
+   * @returns {Promise<any>}
+   */
   handleHttpError(reason) {
     if (reason instanceof WebexHttpError.NetworkOrCORSError) {
       this.logger.warn(
@@ -73,6 +99,10 @@ const MetricsBatcher = Batcher.extend({
     return Reflect.apply(Batcher.prototype.handleHttpError, this, [reason]);
   },
 
+  /**
+   * @param {any} item
+   * @returns {Promise<any>}
+   */
   rerequest(item) {
     return Promise.all([this.getDeferredForRequest(item), this.prepareItem(item)]).then(
       ([defer, req]) => {
@@ -83,6 +113,10 @@ const MetricsBatcher = Batcher.extend({
     );
   },
 
+  /**
+   * @param {any} item
+   * @returns {Promise<any>}
+   */
   fingerprintRequest(item) {
     item[sym] = item[sym] || {
       nextDelay: 1000,
@@ -91,6 +125,10 @@ const MetricsBatcher = Batcher.extend({
     return Promise.resolve(item[sym]);
   },
 
+  /**
+   * @param {any} item
+   * @returns {Promise<any>}
+   */
   fingerprintResponse(item) {
     return Promise.resolve(item[sym]);
   },