@webex/internal-plugin-metrics 3.4.0 → 3.5.0-next.2

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

@@ -30,6 +30,7 @@ describe('internal-plugin-metrics', () => {
     const fakeMeeting = {
       id: '1',
       correlationId: 'correlationId',
+      sessionCorrelationId: undefined,
       callStateForMetrics: {},
       environment: 'meeting_evn',
       locusUrl: 'locus/url',
@@ -354,6 +355,36 @@ describe('internal-plugin-metrics', () => {
 
         assert.deepEqual(res, {
           correlationId: 'correlationId',
+          sessionCorrelationId: undefined,
+          deviceId: 'deviceUrl',
+          locusId: 'url',
+          locusStartTime: 'lastActive',
+          locusUrl: 'locus/url',
+          machineId: 'installationId',
+          mediaAgentAlias: 'mediaAgentAlias',
+          mediaAgentGroupId: 'mediaAgentGroupId',
+          orgId: 'orgId',
+          userId: 'userId',
+        });
+      });
+
+      it('should build identifiers correctly', () => {
+        cd.device = {
+          ...cd.device,
+          config: {installationId: 'installationId'},
+        };
+
+        const res = cd.getIdentifiers({
+          mediaConnections: [
+            {mediaAgentAlias: 'mediaAgentAlias', mediaAgentGroupId: 'mediaAgentGroupId'},
+          ],
+          meeting: fakeMeeting,
+          sessionCorrelationId: 'sessionCorrelationId',
+        });
+
+        assert.deepEqual(res, {
+          correlationId: 'correlationId',
+          sessionCorrelationId: 'sessionCorrelationId',
           deviceId: 'deviceUrl',
           locusId: 'url',
           locusStartTime: 'lastActive',
@@ -372,6 +403,7 @@ describe('internal-plugin-metrics', () => {
             {mediaAgentAlias: 'mediaAgentAlias', mediaAgentGroupId: 'mediaAgentGroupId'},
           ],
           webexConferenceIdStr: 'webexConferenceIdStr',
+          sessionCorrelationId: 'sessionCorrelationId',
           globalMeetingId: 'globalMeetingId',
           meeting: {
             ...fakeMeeting,
@@ -386,6 +418,7 @@ describe('internal-plugin-metrics', () => {
         assert.deepEqual(res, {
           correlationId: 'correlationId',
           webexConferenceIdStr: 'webexConferenceIdStr1',
+          sessionCorrelationId: 'sessionCorrelationId',
           globalMeetingId: 'globalMeetingId1',
           deviceId: 'deviceUrl',
           locusId: 'url',
@@ -417,6 +450,7 @@ describe('internal-plugin-metrics', () => {
 
         assert.deepEqual(res, {
           correlationId: 'correlationId',
+          sessionCorrelationId: undefined,
           webexConferenceIdStr: 'webexConferenceIdStr1',
           globalMeetingId: 'globalMeetingId1',
           deviceId: 'deviceUrl',
@@ -450,6 +484,43 @@ describe('internal-plugin-metrics', () => {
 
         assert.deepEqual(res, {
           correlationId: 'correlationId',
+          sessionCorrelationId: undefined,
+          webexConferenceIdStr: 'webexConferenceIdStr1',
+          globalMeetingId: 'globalMeetingId1',
+          deviceId: 'deviceUrl',
+          locusId: 'url',
+          locusStartTime: 'lastActive',
+          locusUrl: 'locus/url',
+          mediaAgentAlias: 'mediaAgentAlias',
+          mediaAgentGroupId: 'mediaAgentGroupId',
+          orgId: 'orgId',
+          userId: 'userId',
+          webexSiteName: 'siteName1',
+        });
+      });
+
+      it('should build identifiers correctly with a meeting that has sessionCorrelationId', () => {
+        const res = cd.getIdentifiers({
+          mediaConnections: [
+            {mediaAgentAlias: 'mediaAgentAlias', mediaAgentGroupId: 'mediaAgentGroupId'},
+          ],
+          webexConferenceIdStr: 'webexConferenceIdStr',
+          globalMeetingId: 'globalMeetingId',
+          meeting: {
+            ...fakeMeeting,
+            sessionCorrelationId: 'sessionCorrelationId1',
+            meetingInfo: {
+              ...fakeMeeting.meetingInfo,
+              confIdStr: 'webexConferenceIdStr1',
+              meetingId: 'globalMeetingId1',
+              siteName: 'siteName1',
+            },
+          },
+        });
+
+        assert.deepEqual(res, {
+          correlationId: 'correlationId',
+          sessionCorrelationId: 'sessionCorrelationId1',
           webexConferenceIdStr: 'webexConferenceIdStr1',
           globalMeetingId: 'globalMeetingId1',
           deviceId: 'deviceUrl',
@@ -472,6 +543,7 @@ describe('internal-plugin-metrics', () => {
 
         assert.deepEqual(res, {
           correlationId: 'correlationId',
+          sessionCorrelationId: 'unknown',
           webexConferenceIdStr: 'webexConferenceIdStr1',
           deviceId: 'deviceUrl',
           locusUrl: 'locus-url',
@@ -488,6 +560,7 @@ describe('internal-plugin-metrics', () => {
 
         assert.deepEqual(res, {
           correlationId: 'correlationId',
+          sessionCorrelationId: 'unknown',
           globalMeetingId: 'globalMeetingId1',
           deviceId: 'deviceUrl',
           locusUrl: 'locus-url',
@@ -503,6 +576,23 @@ describe('internal-plugin-metrics', () => {
 
         assert.deepEqual(res, {
           correlationId: 'correlationId',
+          sessionCorrelationId: 'unknown',
+          deviceId: 'deviceUrl',
+          locusUrl: 'locus-url',
+          orgId: 'orgId',
+          userId: 'userId',
+        });
+      });
+
+      it('should build identifiers correctly given sessionCorrelationId', () => {
+        const res = cd.getIdentifiers({
+          correlationId: 'correlationId',
+          sessionCorrelationId: 'sessionCorrelationId',
+        });
+
+        assert.deepEqual(res, {
+          correlationId: 'correlationId',
+          sessionCorrelationId: 'sessionCorrelationId',
           deviceId: 'deviceUrl',
           locusUrl: 'locus-url',
           orgId: 'orgId',
@@ -531,6 +621,7 @@ describe('internal-plugin-metrics', () => {
 
         assert.deepEqual(res, {
           correlationId: 'correlationId',
+          sessionCorrelationId: 'unknown',
           locusUrl: 'locus-url',
           deviceId: 'deviceUrl',
           orgId: 'orgId',
@@ -608,6 +699,7 @@ describe('internal-plugin-metrics', () => {
           meeting: fakeMeeting,
           mediaConnections: [{mediaAgentAlias: 'alias', mediaAgentGroupId: '1'}],
           webexConferenceIdStr: undefined,
+          sessionCorrelationId: undefined,
           globalMeetingId: undefined,
         });
         assert.notCalled(generateClientEventErrorPayloadSpy);
@@ -620,6 +712,7 @@ describe('internal-plugin-metrics', () => {
             },
             identifiers: {
               correlationId: 'correlationId',
+              sessionCorrelationId: undefined,
               deviceId: 'deviceUrl',
               locusId: 'url',
               locusStartTime: 'lastActive',
@@ -645,6 +738,7 @@ describe('internal-plugin-metrics', () => {
             },
             identifiers: {
               correlationId: 'correlationId',
+              sessionCorrelationId: undefined,
               deviceId: 'deviceUrl',
               locusId: 'url',
               locusStartTime: 'lastActive',
@@ -681,6 +775,7 @@ describe('internal-plugin-metrics', () => {
               },
               identifiers: {
                 correlationId: 'correlationId',
+                sessionCorrelationId: undefined,
                 deviceId: 'deviceUrl',
                 locusId: 'url',
                 locusStartTime: 'lastActive',
@@ -762,7 +857,7 @@ describe('internal-plugin-metrics', () => {
         ]);
       });
 
-      it('should submit client event successfully with correlationId, webexConferenceIdStr and globalMeetingId', () => {
+      it('should submit client event successfully with correlationId, webexConferenceIdStr, sessionCorrelationId, and globalMeetingId', () => {
         const prepareDiagnosticEventSpy = sinon.spy(cd, 'prepareDiagnosticEvent');
         const submitToCallDiagnosticsSpy = sinon.spy(cd, 'submitToCallDiagnostics');
         const generateClientEventErrorPayloadSpy = sinon.spy(cd, 'generateClientEventErrorPayload');
@@ -773,6 +868,7 @@ describe('internal-plugin-metrics', () => {
           correlationId: 'correlationId',
           webexConferenceIdStr: 'webexConferenceIdStr1',
           globalMeetingId: 'globalMeetingId1',
+          sessionCorrelationId: 'sessionCorrelationId1'
         };
 
         cd.submitClientEvent({
@@ -784,6 +880,7 @@ describe('internal-plugin-metrics', () => {
           correlationId: 'correlationId',
           webexConferenceIdStr: 'webexConferenceIdStr1',
           globalMeetingId: 'globalMeetingId1',
+          sessionCorrelationId: 'sessionCorrelationId1',
           preLoginId: undefined,
         });
 
@@ -798,6 +895,7 @@ describe('internal-plugin-metrics', () => {
             identifiers: {
               correlationId: 'correlationId',
               webexConferenceIdStr: 'webexConferenceIdStr1',
+              sessionCorrelationId: 'sessionCorrelationId1',
               globalMeetingId: 'globalMeetingId1',
               deviceId: 'deviceUrl',
               locusUrl: 'locus-url',
@@ -818,6 +916,7 @@ describe('internal-plugin-metrics', () => {
             identifiers: {
               correlationId: 'correlationId',
               webexConferenceIdStr: 'webexConferenceIdStr1',
+              sessionCorrelationId: 'sessionCorrelationId1',
               globalMeetingId: 'globalMeetingId1',
               deviceId: 'deviceUrl',
               locusUrl: 'locus-url',
@@ -863,6 +962,7 @@ describe('internal-plugin-metrics', () => {
           webexConferenceIdStr: 'webexConferenceIdStr1',
           globalMeetingId: 'globalMeetingId1',
           preLoginId: 'myPreLoginId',
+          sessionCorrelationId: 'sessionCorrelationId1'
         };
 
         cd.submitClientEvent({
@@ -875,6 +975,7 @@ describe('internal-plugin-metrics', () => {
           webexConferenceIdStr: 'webexConferenceIdStr1',
           globalMeetingId: 'globalMeetingId1',
           preLoginId: 'myPreLoginId',
+          sessionCorrelationId: 'sessionCorrelationId1'
         });
 
         assert.notCalled(generateClientEventErrorPayloadSpy);
@@ -887,6 +988,7 @@ describe('internal-plugin-metrics', () => {
             },
             identifiers: {
               correlationId: 'correlationId',
+              sessionCorrelationId: 'sessionCorrelationId1',
               webexConferenceIdStr: 'webexConferenceIdStr1',
               globalMeetingId: 'globalMeetingId1',
               deviceId: 'deviceUrl',
@@ -913,6 +1015,7 @@ describe('internal-plugin-metrics', () => {
               canProceed: true,
               identifiers: {
                 correlationId: 'correlationId',
+                sessionCorrelationId: 'sessionCorrelationId1',
                 userId: 'myPreLoginId',
                 deviceId: 'deviceUrl',
                 orgId: 'orgId',
@@ -949,6 +1052,58 @@ describe('internal-plugin-metrics', () => {
             },
             identifiers: {
               correlationId: 'correlationId2',
+              sessionCorrelationId: undefined,
+              deviceId: 'deviceUrl',
+              locusId: 'url',
+              locusStartTime: 'lastActive',
+              locusUrl: 'locus/url',
+              mediaAgentAlias: 'alias',
+              mediaAgentGroupId: '1',
+              orgId: 'orgId',
+              userId: 'userId',
+            },
+            loginType: 'fakeLoginType',
+            name: 'client.alert.displayed',
+            userType: 'host',
+            isConvergedArchitectureEnabled: undefined,
+            webexSubServiceType: undefined,
+          },
+          eventId: 'my-fake-id',
+          origin: {
+            origin: 'fake-origin',
+          },
+          originTime: {
+            sent: 'not_defined_yet',
+            triggered: now.toISOString(),
+          },
+          senderCountryCode: 'UK',
+          version: 1,
+        });
+      });
+
+      it('should use meeting loginType if present and meetingId provided, with sessionCorrelationId', () => {
+        const submitToCallDiagnosticsSpy = sinon.spy(cd, 'submitToCallDiagnostics');
+        sinon.stub(cd, 'getOrigin').returns({origin: 'fake-origin'});
+        const options = {
+          meetingId: fakeMeeting2.id,
+          mediaConnections: [{mediaAgentAlias: 'alias', mediaAgentGroupId: '1'}],
+          sessionCorrelationId: 'sessionCorrelationId1'
+        };
+
+        cd.submitClientEvent({
+          name: 'client.alert.displayed',
+          options,
+        });
+
+        assert.calledWith(submitToCallDiagnosticsSpy, {
+          event: {
+            canProceed: true,
+            eventData: {
+              webClientDomain: 'whatever',
+            },
+            identifiers: {
+              correlationId: 'correlationId2',
+              sessionCorrelationId: 'sessionCorrelationId1',
               deviceId: 'deviceUrl',
               locusId: 'url',
               locusStartTime: 'lastActive',
@@ -1006,6 +1161,7 @@ describe('internal-plugin-metrics', () => {
             },
             identifiers: {
               correlationId: 'correlationId',
+              sessionCorrelationId: undefined,
               webexConferenceIdStr: 'webexConferenceIdStr1',
               globalMeetingId: 'globalMeetingId1',
               deviceId: 'deviceUrl',
@@ -1084,6 +1240,7 @@ describe('internal-plugin-metrics', () => {
             },
             identifiers: {
               correlationId: 'correlationId',
+              sessionCorrelationId: undefined,
               deviceId: 'deviceUrl',
               locusId: 'url',
               locusStartTime: 'lastActive',
@@ -1159,6 +1316,7 @@ describe('internal-plugin-metrics', () => {
             },
             identifiers: {
               correlationId: 'correlationId',
+              sessionCorrelationId: 'unknown',
               deviceId: 'deviceUrl',
               locusUrl: 'locus-url',
               orgId: 'orgId',
@@ -1232,6 +1390,7 @@ describe('internal-plugin-metrics', () => {
             },
             identifiers: {
               correlationId: 'correlationId',
+              sessionCorrelationId: 'unknown',
               deviceId: 'deviceUrl',
               locusUrl: 'locus-url',
               orgId: 'orgId',
@@ -1311,6 +1470,7 @@ describe('internal-plugin-metrics', () => {
             },
             identifiers: {
               correlationId: 'correlationId',
+              sessionCorrelationId: undefined,
               deviceId: 'deviceUrl',
               locusId: 'url',
               locusStartTime: 'lastActive',
@@ -1417,6 +1577,7 @@ describe('internal-plugin-metrics', () => {
           meetingId: fakeMeeting.id,
           webexConferenceIdStr: 'webexConferenceIdStr1',
           globalMeetingId: 'globalMeetingId1',
+          sessionCorrelationId: 'sessionCorrelationId1'
         };
 
         cd.submitMQE({
@@ -1442,6 +1603,7 @@ describe('internal-plugin-metrics', () => {
             canProceed: true,
             identifiers: {
               correlationId: 'correlationId',
+              sessionCorrelationId: undefined,
               webexConferenceIdStr: 'webexConferenceIdStr1',
               globalMeetingId: 'globalMeetingId1',
               userId: 'userId',
@@ -1481,6 +1643,7 @@ describe('internal-plugin-metrics', () => {
               canProceed: true,
               identifiers: {
                 correlationId: 'correlationId',
+                sessionCorrelationId: undefined,
                 webexConferenceIdStr: 'webexConferenceIdStr1',
                 globalMeetingId: 'globalMeetingId1',
                 userId: 'userId',
@@ -1526,6 +1689,7 @@ describe('internal-plugin-metrics', () => {
               locusUrl: 'locus/url',
               locusId: 'url',
               locusStartTime: 'lastActive',
+              sessionCorrelationId: undefined,
             },
             eventData: {webClientDomain: 'whatever'},
             intervals: [{}],
@@ -2279,6 +2443,7 @@ describe('internal-plugin-metrics', () => {
                       locusUrl: 'locus/url',
                       orgId: 'orgId',
                       userId: 'userId',
+                      sessionCorrelationId: undefined,
                     },
                     loginType: 'login-ci',
                     name: 'client.exit.app',
@@ -2302,6 +2467,7 @@ describe('internal-plugin-metrics', () => {
                     environment: 'meeting_evn',
                     name: 'endpoint',
                     networkType: 'unknown',
+                    upgradeChannel: 'test',
                     userAgent,
                   },
                   originTime: {

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

@@ -235,6 +235,8 @@ describe('internal-plugin-metrics', () => {
   });
 
   describe('getBuildType', () => {
+    const webex = {internal: {metrics: {config: {}}}};
+
     beforeEach(() => {
       process.env.NODE_ENV = 'production';
     });
@@ -246,25 +248,33 @@ describe('internal-plugin-metrics', () => {
       ['https://web.webex.com', true, 'test'],
     ].forEach(([webClientDomain, markAsTestEvent, expected]) => {
       it(`returns expected result for ${webClientDomain}`, () => {
-        assert.deepEqual(getBuildType(webClientDomain, markAsTestEvent as any), expected);
+        assert.deepEqual(getBuildType(webex, webClientDomain, markAsTestEvent as any), expected);
       });
     });
 
     it('returns "test" for NODE_ENV "foo"', () => {
       process.env.NODE_ENV = 'foo';
-      assert.deepEqual(getBuildType('production'), 'test');
+      assert.deepEqual(getBuildType(webex, 'production'), 'test');
     });
 
     it('returns "test" for NODE_ENV "production" and markAsTestEvent = true', () => {
       process.env.NODE_ENV = 'production';
-      assert.deepEqual(getBuildType('my.domain', true), 'test');
+      assert.deepEqual(getBuildType(webex, 'my.domain', true), 'test');
+    });
+
+    it('returns "test" for NODE_ENV "production" when webex.caBuildType = "test"', () => {
+      process.env.NODE_ENV = 'production';
+      assert.deepEqual(
+        getBuildType({internal: {metrics: {config: {caBuildType: 'test'}}}}, 'my.domain'),
+        'test'
+      );
     });
   });
 
   describe('prepareDiagnosticMetricItem', () => {
     let webex: any;
 
-    const check = (eventName: string, expectedEvent: any) => {
+    const check = (eventName: string, expectedEvent: any, expectedUpgradeChannel: string) => {
       const eventPayload = {event: {name: eventName}};
       const item = prepareDiagnosticMetricItem(webex, {
         eventPayload,
@@ -276,6 +286,7 @@ describe('internal-plugin-metrics', () => {
           origin: {
             buildType: 'prod',
             networkType: 'unknown',
+            upgradeChannel: expectedUpgradeChannel
           },
           event: {name: eventName, ...expectedEvent},
         },
@@ -407,19 +418,19 @@ describe('internal-plugin-metrics', () => {
       ],
     ].forEach(([eventName, expectedEvent]) => {
       it(`returns expected result for ${eventName}`, () => {
-        check(eventName as string, expectedEvent);
+        check(eventName as string, expectedEvent, 'gold');
       });
     });
 
-    it('getBuildType returns correct value', () => {
+    it('sets buildType and upgradeChannel correctly', () => {
       const item: any = {
         eventPayload: {
           event: {
             name: 'client.exit.app',
             eventData: {
               markAsTestEvent: true,
-              webClientDomain: 'https://web.webex.com'
-            }
+              webClientDomain: 'https://web.webex.com',
+            },
           },
         },
         type: ['diagnostic-event'],
@@ -428,11 +439,14 @@ describe('internal-plugin-metrics', () => {
       // just submit any event
       prepareDiagnosticMetricItem(webex, item);
       assert.deepEqual(item.eventPayload.origin.buildType, 'test');
+      assert.deepEqual(item.eventPayload.origin.upgradeChannel, 'test');
 
       delete item.eventPayload.origin.buildType;
+      delete item.eventPayload.origin.upgradeChannel;
       item.eventPayload.event.eventData.markAsTestEvent = false;
       prepareDiagnosticMetricItem(webex, item);
       assert.deepEqual(item.eventPayload.origin.buildType, 'prod');
+      assert.deepEqual(item.eventPayload.origin.upgradeChannel, 'gold');
     });
   });
 

package/test/unit/spec/new-metrics.ts

@@ -73,6 +73,20 @@ describe('internal-plugin-metrics', () => {
       sinon.restore();
     })
 
+    it('lazy metrics backend initialization when checking if backend ready', () => {
+      assert.isUndefined(webex.internal.newMetrics.behavioralMetrics);
+      webex.internal.newMetrics.isReadyToSubmitBehavioralEvents();
+      assert.isDefined(webex.internal.newMetrics.behavioralMetrics);
+
+      assert.isUndefined(webex.internal.newMetrics.operationalMetrics);
+      webex.internal.newMetrics.isReadyToSubmitOperationalEvents();
+      assert.isDefined(webex.internal.newMetrics.operationalMetrics);
+
+      assert.isUndefined(webex.internal.newMetrics.businessMetrics)
+      webex.internal.newMetrics.isReadyToSubmitBusinessEvents();
+      assert.isDefined(webex.internal.newMetrics.businessMetrics);
+    })
+  
     it('submits Client Event successfully', () => {
       webex.internal.newMetrics.submitClientEvent({
         name: 'client.alert.displayed',

package/test/unit/spec/operational/operational-metrics.ts

@@ -0,0 +1,115 @@
+import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
+import {BrowserDetection} from '@webex/common';
+import {OperationalMetrics, config, getOSNameInternal} from '@webex/internal-plugin-metrics';
+import uuid from 'uuid';
+
+//@ts-ignore
+global.window = {location: {hostname: 'whatever'}, navigator: {language: 'language'}};
+process.env.NODE_ENV = 'test';
+
+const {getOSVersion, getBrowserName, getBrowserVersion} = BrowserDetection();
+
+describe('internal-plugin-metrics', () => {
+  describe('OperationalMetrics', () => {
+    let webex;
+    let now;
+    let operationalMetrics: OperationalMetrics;
+
+    const tags = {key: 'val'};
+
+    beforeEach(() => {
+      now = new Date();
+
+      webex = {
+        canAuthorize: true,
+        version: 'webex-version',
+        internal: {
+          services: {
+            get: () => 'locus-url',
+          },
+          metrics: {
+            submitClientMetrics: sinon.stub(),
+            config: {...config.metrics},
+          },
+          newMetrics: {},
+          device: {
+            userId: 'userId',
+            url: 'https://wdm-intb.ciscospark.com/wdm/api/v1/devices/deviceId',
+            orgId: 'orgId',
+          },
+        },
+        meetings: {
+          config: {
+            metrics: {
+              clientType: 'TEAMS_CLIENT',
+              subClientType: 'WEB_APP',
+              clientName: 'Cantina',
+            },
+          },
+          geoHintInfo: {
+            clientAddress: '1.3.4.5',
+            countryCode: 'UK',
+          },
+        },
+        credentials: {
+          isUnverifiedGuest: false,
+        },
+        prepareFetchOptions: sinon.stub().callsFake((opts: any) => ({...opts, foo: 'bar'})),
+        request: sinon.stub().resolves({body: {}}),
+        logger: {
+          log: sinon.stub(),
+          error: sinon.stub(),
+        },
+      };
+
+      sinon.createSandbox();
+      sinon.useFakeTimers(now.getTime());
+      operationalMetrics = new OperationalMetrics({}, {parent: webex});
+      sinon.stub(uuid, 'v4').returns('my-fake-id');
+    });
+
+    afterEach(() => {
+      sinon.restore();
+    });
+
+    describe('#sendEvent', () => {
+      it('should send correctly shaped operational event (check name building and internal tagged event building)', () => {
+        // For some reasons `jest` isn't available when testing form build server - so can't use `jest.fn()` here...
+        const requestCalls = [];
+        const request = function(arg) { requestCalls.push(arg) }
+
+        operationalMetrics.clientMetricsBatcher.request = request;
+        
+        assert.equal(requestCalls.length, 0)
+        operationalMetrics.submitOperationalEvent({ name: "foobar", payload: {bar:"gee"} })
+        assert.equal(requestCalls.length, 1)
+        assert.deepEqual(requestCalls[0], {
+          context: {
+            app: {version: 'webex-version'},
+            device: {id: 'deviceId'},
+            locale: 'language',
+            os: {
+              name: getOSNameInternal(),
+              version: getOSVersion(),
+            },
+          },
+          metricName: 'foobar',
+          tags: {
+            browser: getBrowserName(),
+            browserHeight: window.innerHeight,
+            browserVersion: getBrowserVersion(),
+            browserWidth: window.innerWidth,
+            domain: window.location.hostname,
+            inIframe: false,
+            locale: window.navigator.language,
+            os: getOSNameInternal(),
+            bar: "gee"
+          },
+          timestamp: requestCalls[0].timestamp, // This is to bypass time check, which is correctly tested in behavioral-metrics tests.
+          type: ['operational'],
+        });
+      })
+    })
+  });
+});

package/test/unit/spec/prelogin-metrics-batcher.ts

@@ -82,6 +82,7 @@ describe('internal-plugin-metrics', () => {
                   origin: {
                     buildType: 'test',
                     networkType: 'unknown',
+                    upgradeChannel: 'test',
                   },
                   originTime: {
                     sent: dateAfterBatcherWait.toISOString(),
@@ -211,7 +212,7 @@ describe('internal-plugin-metrics', () => {
         // item also gets assigned a delay property but the key is a Symbol and haven't been able to test that..
         assert.deepEqual(calls.args[0].eventPayload, {
           event: 'my.event',
-          origin: {buildType: 'test', networkType: 'unknown'},
+          origin: {buildType: 'test', networkType: 'unknown', upgradeChannel: 'test'},
         });
 
         assert.deepEqual(calls.args[0].type, ['diagnostic-event']);
@@ -225,6 +226,7 @@ describe('internal-plugin-metrics', () => {
           origin: {
             buildType: 'test',
             networkType: 'unknown',
+            upgradeChannel: 'test',
           },
         });
         assert.deepEqual(prepareDiagnosticMetricItemCalls[0].args[1].type, ['diagnostic-event']);