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

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

@@ -841,6 +841,60 @@ describe('internal-plugin-metrics', () => {
           userId: 'preLoginId',
         });
       });
+
+      it('should use the userId from credentials when no device userId is available', () => {
+        cd.device.userId = undefined;
+        webex.credentials.getUserId = sinon.stub().returns('credentials-user-id');
+
+        const res = cd.getIdentifiers({
+          correlationId: 'correlationId',
+        });
+
+        assert.deepEqual(res, {
+          correlationId: 'correlationId',
+          locusUrl: 'locus-url',
+          deviceId: 'deviceUrl',
+          orgId: 'orgId',
+          userId: 'credentials-user-id',
+        });
+      });
+
+      it('should prefer the device userId over the credentials userId', () => {
+        webex.credentials.getUserId = sinon.stub().returns('credentials-user-id');
+
+        const res = cd.getIdentifiers({
+          correlationId: 'correlationId',
+        });
+
+        assert.equal(res.userId, 'userId');
+        assert.notCalled(webex.credentials.getUserId);
+      });
+
+      it('should fall back to preLoginId when neither the device nor credentials provide a userId', () => {
+        cd.device.userId = undefined;
+        webex.credentials.getUserId = sinon.stub().throws(new Error('no user token available'));
+
+        const res = cd.getIdentifiers({
+          correlationId: 'correlationId',
+          preLoginId: 'preLoginId',
+        });
+
+        assert.equal(res.userId, 'preLoginId');
+      });
+    });
+
+    describe('#getUserIdFromCredentials', () => {
+      it('should return the userId from credentials', () => {
+        webex.credentials.getUserId = sinon.stub().returns('credentials-user-id');
+
+        assert.equal(cd.getUserIdFromCredentials(), 'credentials-user-id');
+      });
+
+      it('should return undefined when credentials cannot provide a userId', () => {
+        webex.credentials.getUserId = sinon.stub().throws(new Error('no user token available'));
+
+        assert.isUndefined(cd.getUserIdFromCredentials());
+      });
     });
 
     it('should prepare diagnostic event successfully', () => {
@@ -3730,7 +3784,7 @@ describe('internal-plugin-metrics', () => {
           serviceErrorCode: undefined,
           errorCode: 1026,
           rawErrorMessage: '{}\nundefined https://example.com\nWEBEX_TRACKING_ID: undefined\n',
-          httpStatusCode: 0,
+          httpCode: 0,
         });
       });
 
@@ -3847,7 +3901,7 @@ describe('internal-plugin-metrics', () => {
           serviceErrorCode: undefined,
           errorCode: 1026,
           rawErrorMessage: '{}\nundefined https://example.com\nWEBEX_TRACKING_ID: undefined\n',
-          httpStatusCode: 0,
+          httpCode: 0,
         });
       });
 
@@ -3869,7 +3923,7 @@ describe('internal-plugin-metrics', () => {
           serviceErrorCode: undefined,
           errorCode: 1010,
           rawErrorMessage: '{}\nundefined https://example.com\nWEBEX_TRACKING_ID: undefined\n',
-          httpStatusCode: 0,
+          httpCode: 0,
         });
       });
 
@@ -3895,7 +3949,7 @@ describe('internal-plugin-metrics', () => {
           serviceErrorCode: undefined,
           errorCode: 1010,
           rawErrorMessage: '{}\nundefined https://example.com\nWEBEX_TRACKING_ID: undefined\n',
-          httpStatusCode: 0,
+          httpCode: 0,
         });
       });
 
@@ -4000,8 +4054,144 @@ describe('internal-plugin-metrics', () => {
         });
       });
 
-      describe('httpStatusCode', () => {
-        it('should include httpStatusCode for browser media errors', () => {
+      describe('httpCode', () => {
+        it('should identify an outgoing Locus 429', () => {
+          const rawErrorMessage =
+            'partition 371 on PARALLEL_EXECUTOR_PARTITION_KEY_QUEUE_FULL state';
+          const [res] = cd.generateClientEventErrorPayload({
+            message: rawErrorMessage,
+            statusCode: 429,
+            options: {uri: 'https://locus.example.com/locus/api/v1/loci/call'},
+          });
+
+          assert.deepEqual(res, {
+            category: 'signaling',
+            errorCode: 1002,
+            errorDescription: 'LocusRateLimitedOutgoing',
+            fatal: true,
+            name: 'locus.response',
+            rawErrorMessage,
+            serviceErrorCode: undefined,
+            shownToUser: false,
+            httpCode: 429,
+          });
+        });
+
+        [
+          ['media', 'https://example.com/locus/api/v1/loci/123/media'],
+          ['hashtree', 'https://example.com/locus/api/v1/loci/123/hashtree'],
+          ['host-only Locus URL', 'https://locus.example.com/api/v1/resource'],
+          ['query-only Locus URL', 'https://example.com/api/v1/resource?service=locus'],
+        ].forEach(([operation, uri]) => {
+          it(`should identify a Locus 429 for ${operation}`, () => {
+            const [res] = cd.generateClientEventErrorPayload({
+              message: 'Locus rate limited',
+              statusCode: 429,
+              options: {uri},
+            });
+
+            assert.equal(res.errorCode, 1002);
+            assert.equal(res.errorDescription, 'LocusRateLimitedOutgoing');
+            assert.equal(res.httpCode, 429);
+          });
+        });
+
+        it('should identify an unavailable Locus 503', () => {
+          const rawErrorMessage = 'Service unavailable';
+          const [res] = cd.generateClientEventErrorPayload({
+            message: rawErrorMessage,
+            statusCode: 503,
+            options: {uri: 'https://locus.example.com/locus/api/v1/loci/call'},
+          });
+
+          assert.deepEqual(res, {
+            category: 'signaling',
+            errorCode: 1003,
+            errorDescription: 'LocusUnavailable',
+            fatal: true,
+            name: 'locus.response',
+            rawErrorMessage,
+            serviceErrorCode: undefined,
+            shownToUser: false,
+            httpCode: 503,
+          });
+        });
+
+        it('should prefer a specific service error mapping over the Locus HTTP status', () => {
+          const rawErrorMessage = 'Fraud detected';
+          const [res] = cd.generateClientEventErrorPayload({
+            body: {errorCode: 2423012},
+            message: rawErrorMessage,
+            statusCode: 429,
+            options: {uri: 'https://locus.example.com/locus/api/v1/loci/call'},
+          });
+
+          assert.deepEqual(res, {
+            category: 'expected',
+            errorCode: 12000,
+            errorDescription: 'FraudDetection',
+            fatal: true,
+            name: 'locus.response',
+            rawErrorMessage,
+            serviceErrorCode: 2423012,
+            shownToUser: true,
+            httpCode: 429,
+          });
+        });
+
+        it('should retain an unmapped service error code on the Locus HTTP status payload', () => {
+          const rawErrorMessage = 'Locus rate limited';
+          const [res] = cd.generateClientEventErrorPayload({
+            body: {errorCode: 2429999},
+            message: rawErrorMessage,
+            statusCode: 429,
+            options: {uri: 'https://locus.example.com/locus/api/v1/loci/call'},
+          });
+
+          assert.deepEqual(res, {
+            category: 'signaling',
+            errorCode: 1002,
+            errorDescription: 'LocusRateLimitedOutgoing',
+            fatal: true,
+            name: 'locus.response',
+            rawErrorMessage,
+            serviceErrorCode: 2429999,
+            shownToUser: false,
+            httpCode: 429,
+          });
+        });
+
+        it('should not identify a non-Locus 429 as a Locus rate limit', () => {
+          const [res] = cd.generateClientEventErrorPayload({
+            message: 'Too many requests',
+            statusCode: 429,
+            options: {uri: 'https://example.com/api/v1/resource'},
+          });
+
+          assert.deepEqual(res, {
+            category: 'other',
+            errorCode: 9999,
+            errorDescription: 'UnknownError',
+            fatal: true,
+            name: 'other',
+            rawErrorMessage: 'Too many requests',
+            serviceErrorCode: 9999,
+            shownToUser: false,
+            httpCode: 429,
+          });
+        });
+
+        it('should keep the fallback classification when a 429 has no request URL', () => {
+          const [res] = cd.generateClientEventErrorPayload({
+            message: 'Too many requests',
+            statusCode: 429,
+          });
+
+          assert.equal(res.errorCode, 9999);
+          assert.equal(res.httpCode, 429);
+        });
+
+        it('should include httpCode for browser media errors', () => {
           const [res, cached] = cd.generateClientEventErrorPayload({
             name: 'PermissionDeniedError',
             message: 'bad times',
@@ -4019,11 +4209,11 @@ describe('internal-plugin-metrics', () => {
             rawErrorMessage: 'bad times',
             serviceErrorCode: undefined,
             shownToUser: false,
-            httpStatusCode: 401,
+            httpCode: 401,
           });
         });
 
-        it('should include httpStatusCode for SdpOfferCreationErrors', () => {
+        it('should include httpCode for SdpOfferCreationErrors', () => {
           const [res, cached] = cd.generateClientEventErrorPayload({
             name: 'SdpOfferCreationError',
             message: 'bad times',
@@ -4041,11 +4231,11 @@ describe('internal-plugin-metrics', () => {
             rawErrorMessage: 'bad times',
             serviceErrorCode: undefined,
             shownToUser: true,
-            httpStatusCode: 404,
+            httpCode: 404,
           });
         });
 
-        it('should include httpStatusCode for service error codes', () => {
+        it('should include httpCode for service error codes', () => {
           const [res, cached] = cd.generateClientEventErrorPayload({
             body: {errorCode: 58400},
             message: 'bad times',
@@ -4060,11 +4250,11 @@ describe('internal-plugin-metrics', () => {
             rawErrorMessage: 'bad times',
             serviceErrorCode: 58400,
             shownToUser: false,
-            httpStatusCode: 400,
+            httpCode: 400,
           });
         });
 
-        it('should include httpStatusCode for locus service error codes', () => {
+        it('should include httpCode for locus service error codes', () => {
           const [res, cached] = cd.generateClientEventErrorPayload({
             body: {errorCode: 2403001},
             message: 'bad times',
@@ -4079,11 +4269,11 @@ describe('internal-plugin-metrics', () => {
             rawErrorMessage: 'bad times',
             serviceErrorCode: 2403001,
             shownToUser: false,
-            httpStatusCode: 400,
+            httpCode: 400,
           });
         });
 
-        it('should include httpStatusCode for meetingInfo service error codes', () => {
+        it('should include httpCode for meetingInfo service error codes', () => {
           const [res, cached] = cd.generateClientEventErrorPayload({
             body: {data: {meetingInfo: {}}},
             message: 'bad times',
@@ -4098,11 +4288,11 @@ describe('internal-plugin-metrics', () => {
             rawErrorMessage: 'bad times',
             serviceErrorCode: undefined,
             shownToUser: false,
-            httpStatusCode: 400,
+            httpCode: 400,
           });
         });
 
-        it('should include httpStatusCode for network errors', () => {
+        it('should include httpCode for network errors', () => {
           const error = new WebexHttpError.NetworkOrCORSError({
             statusCode: 400,
             options: {service: '', headers: {}},
@@ -4117,11 +4307,11 @@ describe('internal-plugin-metrics', () => {
             rawErrorMessage: 'undefined\nundefined /undefined\nWEBEX_TRACKING_ID: undefined\n',
             serviceErrorCode: undefined,
             shownToUser: false,
-            httpStatusCode: 400,
+            httpCode: 400,
           });
         });
 
-        it('should include httpStatusCode for unauthorized errors', () => {
+        it('should include httpCode for unauthorized errors', () => {
           const error = new WebexHttpError.Unauthorized({
             statusCode: 401,
             options: {service: '', headers: {}},
@@ -4136,11 +4326,11 @@ describe('internal-plugin-metrics', () => {
             rawErrorMessage: 'undefined\nundefined /undefined\nWEBEX_TRACKING_ID: undefined\n',
             serviceErrorCode: undefined,
             shownToUser: false,
-            httpStatusCode: 401,
+            httpCode: 401,
           });
         });
 
-        it('should include httpStatusCode for unknown errors', () => {
+        it('should include httpCode for unknown errors', () => {
           const [res, cached] = cd.generateClientEventErrorPayload({
             message: 'bad times',
             statusCode: 404,
@@ -4154,7 +4344,7 @@ describe('internal-plugin-metrics', () => {
             serviceErrorCode: 9999,
             errorDescription: 'UnknownError',
             rawErrorMessage: 'bad times',
-            httpStatusCode: 404,
+            httpCode: 404,
           });
         });
       });

package/test/unit/spec/metrics.js

@@ -13,7 +13,7 @@ import {BrowserDetection} from '@webex/common';
 const {getOSVersion} = BrowserDetection();
 
 //@ts-ignore
-global.window = {location: {hostname: 'whatever'}};
+global.window = {location: {hostname: 'whatever', origin: 'https://whatever'}};
 function promiseTick(count) {
   let promise = Promise.resolve();
 
@@ -30,6 +30,7 @@ describe('plugin-metrics', () => {
     let webex;
     let metrics;
     let clock;
+    let previousWindow;
 
     const eventName = 'test_event';
     const mockPayload = {
@@ -67,10 +68,15 @@ describe('plugin-metrics', () => {
 
     beforeEach(() => {
       clock = FakeTimers.install({now: 0});
+      previousWindow = global.window;
+      // Other test files also replace the shared browser mock. Restore the
+      // location needed to verify that app_url prefers the browser origin.
+      global.window = {location: {hostname: 'whatever', origin: 'https://whatever'}};
     });
 
     afterEach(() => {
       clock.uninstall();
+      global.window = previousWindow;
     });
 
     beforeEach(() => {
@@ -107,10 +113,10 @@ describe('plugin-metrics', () => {
       webex.meetings = {
         config: {
           metrics: {
-            clientVersion: '43.0.105'
-          }
-        }
-      }
+            clientVersion: '43.0.105',
+          },
+        },
+      };
 
       sinon.spy(webex, 'request');
       sinon.spy(metrics, 'aliasUser');
@@ -186,6 +192,9 @@ describe('plugin-metrics', () => {
           },
           metricName: 'test',
           tags: {
+            app_name: 'appName',
+            app_url: 'https://whatever',
+            app_version: 'appVersion',
             appVersion: '43.0.105',
             browser: '',
             domain: 'whatever',