@atlaskit/insm 0.1.2 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @atlaskit/insm
 
+## 0.2.0
+
+### Minor Changes
+
+- [`c6c113481c118`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/c6c113481c118) -
+  Updates limited mode to include lcm sizes in decision to engage.
+
+### Patch Changes
+
+- Updated dependencies
+
+## 0.1.3
+
+### Patch Changes
+
+- Updated dependencies
+
 ## 0.1.2
 
 ### Patch Changes

package/README.md

@@ -38,6 +38,9 @@ insm.session.startHeavyTask('paste-handler');
 insm.session.endHeavyTask('paste-handler');
 ```
 
+Note: For tracking page initialisation - if you use the special `PageLoad` key, the duration will be
+tracked on the resulting session event.
+
 ### Adding additional information to the session
 
 Additional session information can be added through the `addProperties` api.
@@ -169,6 +172,20 @@ insm.start(experienceKey, {
 Note: calling this will end any existing experience (unless the experience key and properties
 match - in which case no session change will occur).
 
+#### Updating a page session experienceKey after it's started
+
+In some scenarios you may need to update the running sessions experience key after it has started,
+in these cases you can use `overrideExperienceKey`.
+
+If there is a running experience, it will update the running experiences name.
+
+If there is no running experience (ie. if the original experienceKey had not been whitelisted), it
+will start a new experience using the last started experienceProperties.
+
+```ts
+insm.overrideExperienceKey('new-key');
+```
+
 #### Naming guidance
 
 Choose an `experienceKey` that reflects the product and content type you want to analyze.

package/dist/cjs/index.js

@@ -16,8 +16,6 @@ function init(options) {
 }
 function insmInitialised() {
   if (!initialisedInsm) {
-    // eslint-disable-next-line no-console
-    console.error('INSM used when not initialised');
     return false;
   }
   return true;
@@ -42,6 +40,11 @@ var insm = exports.insm = {
       initialisedInsm.start(experienceKey, experienceProperties);
     }
   },
+  overrideExperienceKey: function overrideExperienceKey(experienceKey) {
+    if (insmInitialised()) {
+      initialisedInsm.overrideExperienceKey(experienceKey);
+    }
+  },
   stopEarly: function stopEarly(reasonKey, description) {
     if (insmInitialised()) {
       initialisedInsm.stopEarly(reasonKey, description);

package/dist/cjs/insm-period.js

@@ -8,10 +8,10 @@ exports.PeriodTracking = void 0;
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _platformFeatureFlags = require("@atlaskit/platform-feature-flags");
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-/* eslint-disable @repo/internal/dom-events/no-unsafe-event-listeners */
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; } /* eslint-disable @repo/internal/dom-events/no-unsafe-event-listeners */
 var PeriodTracking = exports.PeriodTracking = /*#__PURE__*/function () {
   function PeriodTracking(session) {
     (0, _classCallCheck2.default)(this, PeriodTracking);
@@ -157,6 +157,24 @@ var PeriodTracking = exports.PeriodTracking = /*#__PURE__*/function () {
     key: "endResults",
     get: function get() {
       this.changePeriodAndTrackLast(this.state);
+      if ((0, _platformFeatureFlags.fg)('cc_editor_insm_fix_attributes')) {
+        return {
+          active: {
+            features: Array.from(this.periodMeasurements.active.features),
+            heavyTasks: Array.from(this.periodMeasurements.active.heavyTasks),
+            measurements: this.periodMeasurements.active.measurements,
+            duration: this.periodMeasurements.active.duration,
+            count: this.periodMeasurements.active.count
+          },
+          inactive: {
+            features: Array.from(this.periodMeasurements.inactive.features),
+            heavyTasks: Array.from(this.periodMeasurements.inactive.heavyTasks),
+            measurements: this.periodMeasurements.inactive.measurements,
+            duration: this.periodMeasurements.inactive.duration,
+            count: this.periodMeasurements.inactive.count
+          }
+        };
+      }
       return this.periodMeasurements;
     }
   }, {

package/dist/cjs/insm-session.js

@@ -8,7 +8,10 @@ exports.INSMSession = void 0;
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _bowserUltralight = _interopRequireDefault(require("bowser-ultralight"));
+var _expValEquals = require("@atlaskit/tmp-editor-statsig/exp-val-equals");
 var _insmPeriod = require("./insm-period");
+var _LongAnimationFrameMeasurer = require("./session-measurers/LongAnimationFrameMeasurer");
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
@@ -18,11 +21,14 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
  * Only intended for internal use.
  *
  * Exported for consumers who may require the type.
+ *
+ * Note: Events are not reliably fired from mobile browsers (ie. when a browser is closed when not in use)
  */
 var INSMSession = exports.INSMSession = /*#__PURE__*/function () {
   function INSMSession(experienceKey, experienceProperties, insm) {
     (0, _classCallCheck2.default)(this, INSMSession);
     (0, _defineProperty2.default)(this, "startedAt", performance.now());
+    (0, _defineProperty2.default)(this, "pageLoadTime", null);
     (0, _defineProperty2.default)(this, "running", true);
     (0, _defineProperty2.default)(this, "addedProperties", []);
     (0, _defineProperty2.default)(this, "runningFeatures", new Set());
@@ -30,16 +36,33 @@ var INSMSession = exports.INSMSession = /*#__PURE__*/function () {
     this.experienceProperties = experienceProperties;
     this.insm = insm;
     this.periodTracking = new _insmPeriod.PeriodTracking(this);
-
-    /**
-     * Note: Events are not reliably fired from mobile browsers (ie. when a browser is closed when not in use)
-     */
+    this.longAnimationFrameMeasurer = new _LongAnimationFrameMeasurer.LongAnimationFrameMeasurer({
+      initial: this.experienceProperties.initial,
+      limit: 3,
+      insmSession: this,
+      reportingThreshold: 500
+    });
   }
 
   /**
-   * Adds a feature to the currently running session
+   * Completes the page load timing. This is called automatically when ending a heavy task
+   * with the key 'PageLoad'.
    */
   return (0, _createClass2.default)(INSMSession, [{
+    key: "completePageLoad",
+    value: function completePageLoad() {
+      this.pageLoadTime = performance.now() - this.startedAt;
+    }
+  }, {
+    key: "updateExperienceKey",
+    value: function updateExperienceKey(experienceKey) {
+      this.experienceKey = experienceKey;
+    }
+
+    /**
+     * Adds a feature to the currently running session
+     */
+  }, {
     key: "startFeature",
     value: function startFeature(featureName) {
       var _this$periodTracking;
@@ -130,7 +153,7 @@ var INSMSession = exports.INSMSession = /*#__PURE__*/function () {
   }, {
     key: "end",
     value: function end(endDetails) {
-      var _this$insm$analyticsW;
+      var _periodResults$active, _periodResults$active2, _periodResults$active3, _periodResults$active4, _this$insm$analyticsW;
       if (this.running === false) {
         // If an experience has already been ended -- don't repeat the ending
         return;
@@ -163,22 +186,73 @@ var INSMSession = exports.INSMSession = /*#__PURE__*/function () {
       var operationalEvent = {
         actionSubject: 'insm',
         action: 'measured',
-        attributes: _objectSpread(_objectSpread({}, evaluatedAddedProperties), {}, {
+        attributes: _objectSpread(_objectSpread(_objectSpread({}, evaluatedAddedProperties), {}, {
           experienceKey: this.experienceKey,
           initial: this.experienceProperties.initial,
           contentId: this.experienceProperties.contentId,
           timing: {
             startedAt: this.startedAt,
+            // Note: this will not match up with the periods sum of durations, as it includes
+            // time paused when heavy tasks were running, and/or the page is in the background.
             duration: duration
           },
           periods: periodResults,
           endDetails: endDetails
+        }, (0, _expValEquals.expValEquals)('cc_editor_insm_outlier_events', 'cohort', 'test') ? {
+          longScripts: this.longAnimationFrameMeasurer.current,
+          pageLoadTime: this.pageLoadTime,
+          deviceDetails: getDeviceDetails()
+        } : {}), {}, {
+          // these health attributes drive our SLOs
+          healthAFPS: (_periodResults$active = periodResults.active.measurements.afps) !== null && _periodResults$active !== void 0 && _periodResults$active.average ? ((_periodResults$active2 = periodResults.active.measurements.afps) === null || _periodResults$active2 === void 0 ? void 0 : _periodResults$active2.average) >= 50 : undefined,
+          healthINP: (_periodResults$active3 = periodResults.active.measurements.inp) !== null && _periodResults$active3 !== void 0 && _periodResults$active3.average ? ((_periodResults$active4 = periodResults.active.measurements.inp) === null || _periodResults$active4 === void 0 ? void 0 : _periodResults$active4.average) >= 200 : undefined
         }),
         highPriority: true,
         tags: ['editor'],
         source: 'unknown'
       };
       (_this$insm$analyticsW = this.insm.analyticsWebClient) === null || _this$insm$analyticsW === void 0 || _this$insm$analyticsW.sendOperationalEvent(operationalEvent);
+      this.longAnimationFrameMeasurer.cleanup();
     }
   }]);
-}();
+}(); // Functionality vendored from UFO
+function getDeviceDetails() {
+  var _navigator$connection, _navigator$connection2, _navigator$connection3;
+  var telemetry = {};
+
+  // /platform/packages/data/ufo-internal/src/core/publisher/plugins/browser.ts
+  if (_bowserUltralight.default.getParser) {
+    var _ref;
+    var browser = _bowserUltralight.default.getParser(((_ref = typeof window !== 'undefined' && !!window ? window : undefined) === null || _ref === void 0 || (_ref = _ref.navigator) === null || _ref === void 0 ? void 0 : _ref.userAgent) || '');
+    Object.assign(telemetry, {
+      'event:browser:name': browser.getBrowserName(),
+      'event:browser:version': browser.getBrowserVersion()
+    });
+  }
+
+  // /platform/packages/data/ufo-internal/src/core/publisher/plugins/cpus.ts
+  Object.assign(telemetry, {
+    'event:cpus': navigator.hardwareConcurrency
+  });
+
+  // /platform/packages/data/ufo-internal/src/core/publisher/plugins/memory.ts
+  // @ts-ignore: deviceMemory is exposed in some browsers
+  Object.assign(telemetry, {
+    'event:memory': navigator.deviceMemory
+  });
+
+  // /platform/packages/data/ufo-internal/src/core/publisher/plugins/network.ts
+  Object.assign(telemetry, {
+    // Network
+    // @ts-ignore: connection is available in some browsers
+    // eslint-disable-next-line compat/compat
+    'event:network:effectiveType': (_navigator$connection = navigator.connection) === null || _navigator$connection === void 0 ? void 0 : _navigator$connection.effectiveType,
+    // @ts-ignore: connection is available in some browsers
+    // eslint-disable-next-line compat/compat
+    'event:network:rtt': (_navigator$connection2 = navigator.connection) === null || _navigator$connection2 === void 0 ? void 0 : _navigator$connection2.rtt,
+    // @ts-ignore: connection is available in some browsers
+    // eslint-disable-next-line compat/compat
+    'event:network:downlink': (_navigator$connection3 = navigator.connection) === null || _navigator$connection3 === void 0 ? void 0 : _navigator$connection3.downlink
+  });
+  return telemetry;
+}

package/dist/cjs/insm.js

@@ -11,6 +11,7 @@ var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/de
 var _insmSession = require("./insm-session");
 var _afps = require("./period-measurers/afps");
 var _inp = require("./inp-measurers/inp");
+var _expValEquals = require("@atlaskit/tmp-editor-statsig/exp-val-equals");
 var INSM = exports.INSM = /*#__PURE__*/function () {
   function INSM(options) {
     var _this = this;
@@ -53,14 +54,18 @@ var INSM = exports.INSM = /*#__PURE__*/function () {
    * Starts a heavy task in the currently running session.
    *
    * This also pauses measurement.
+   *
+   * For PageLoads using the key 'PageLoad' will mean the heavy task duration
+   * is added to the insm session event as pageLoadTime.
    */
   return (0, _createClass2.default)(INSM, [{
     key: "startHeavyTask",
     value: function startHeavyTask(heavyTaskName) {
-      var _this$runningSession2, _this$runningSession3;
+      var _this$runningSession2, _this$runningSession3, _this$runningSession4;
       this.runningHeavyTasks.add(heavyTaskName);
       (_this$runningSession2 = this.runningSession) === null || _this$runningSession2 === void 0 || (_this$runningSession2 = _this$runningSession2.periodTracking) === null || _this$runningSession2 === void 0 || _this$runningSession2.startHeavyTask(heavyTaskName);
       (_this$runningSession3 = this.runningSession) === null || _this$runningSession3 === void 0 || _this$runningSession3.periodTracking.pause(heavyTaskName);
+      (_this$runningSession4 = this.runningSession) === null || _this$runningSession4 === void 0 || _this$runningSession4.longAnimationFrameMeasurer.pause();
     }
 
     /**
@@ -69,24 +74,38 @@ var INSM = exports.INSM = /*#__PURE__*/function () {
   }, {
     key: "endHeavyTask",
     value: function endHeavyTask(heavyTaskName) {
-      var _this$runningSession4;
+      var _this$runningSession5;
       this.runningHeavyTasks.delete(heavyTaskName);
-      (_this$runningSession4 = this.runningSession) === null || _this$runningSession4 === void 0 || _this$runningSession4.periodTracking.resume(heavyTaskName);
+      (_this$runningSession5 = this.runningSession) === null || _this$runningSession5 === void 0 || _this$runningSession5.periodTracking.resume(heavyTaskName);
+      if (this.runningHeavyTasks.size === 0) {
+        var _this$runningSession6;
+        (_this$runningSession6 = this.runningSession) === null || _this$runningSession6 === void 0 || _this$runningSession6.longAnimationFrameMeasurer.resume();
+      }
+      if ((0, _expValEquals.expValEquals)('cc_editor_insm_outlier_events', 'cohort', 'test')) {
+        if (heavyTaskName === 'PageLoad') {
+          var _this$runningSession7;
+          (_this$runningSession7 = this.runningSession) === null || _this$runningSession7 === void 0 || _this$runningSession7.completePageLoad();
+        }
+      }
     }
 
     /**
      * Call this when starting a new experience.  This is expected to be wired to the product
      * routing solution.
      *
-     * It's expected this call will be paired with a `insm.session.startHeavyTask('page-load')` and subsequent `insm.session.endHeavyTask('page-load')`
-     * so that performance degradations linked to the page initialisation are excluded from the active interactivity monitoring.
+     * It's expected this call will be paired with a `insm.session.startHeavyTask('PageLoad')` and
+     * subsequent `insm.session.endHeavyTask('PageLoad')` so that performance degradations linked
+     * to the page initialisation are excluded from the active interactivity monitoring.
+     *
+     * Using the key 'PageLoad' is special and will result in the heavy task duration being added to the
+     * insm session event as pageLoadTime.
      *
      *
      * ```ts
      * insm.start('edit-page', { initial: true, contentId: '9001' })
-     * insm.session.startHeavyTask(''page-load')
+     * insm.session.startHeavyTask('PageLoad')
      * // ... heavy initialisation work
-     * insm.session.endHeavyTask(''page-load')
+     * insm.session.endHeavyTask('PageLoad')
      * ```
      */
   }, {
@@ -100,10 +119,31 @@ var INSM = exports.INSM = /*#__PURE__*/function () {
           contentId: experienceProperties.contentId
         });
       }
+      this.lastStartedExperienceProperties = experienceProperties;
       if ((_this$options$experie = this.options.experiences[experienceKey]) !== null && _this$options$experie !== void 0 && _this$options$experie.enabled) {
         this.runningSession = new _insmSession.INSMSession(experienceKey, experienceProperties, this);
       }
     }
+  }, {
+    key: "overrideExperienceKey",
+    value:
+    /**
+     * Call this to update the name of the running session after it's started
+     * In the case it's been started with an unregistered name, and there is not running
+     * session. This will also trigger the session being started.
+     */
+    function overrideExperienceKey(experienceKey) {
+      if (this.runningSession !== undefined) {
+        // If there is a running session - we update its name
+        this.runningSession.updateExperienceKey(experienceKey);
+      } else {
+        var _this$options$experie2;
+        // otherwise - we assume the last session was not registered, and start it with the new name
+        if ((_this$options$experie2 = this.options.experiences[experienceKey]) !== null && _this$options$experie2 !== void 0 && _this$options$experie2.enabled && this.lastStartedExperienceProperties) {
+          this.runningSession = new _insmSession.INSMSession(experienceKey, this.lastStartedExperienceProperties, this);
+        }
+      }
+    }
 
     /**
      * This prematurely halts any running experience measurement. It's expected to be used in
@@ -112,8 +152,8 @@ var INSM = exports.INSM = /*#__PURE__*/function () {
   }, {
     key: "stopEarly",
     value: function stopEarly(reasonKey, description) {
-      var _this$runningSession5;
-      (_this$runningSession5 = this.runningSession) === null || _this$runningSession5 === void 0 || _this$runningSession5.earlyStop(reasonKey, description);
+      var _this$runningSession8;
+      (_this$runningSession8 = this.runningSession) === null || _this$runningSession8 === void 0 || _this$runningSession8.earlyStop(reasonKey, description);
     }
 
     /**

package/dist/cjs/session-measurers/LongAnimationFrameMeasurer.js

@@ -0,0 +1,164 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LongAnimationFrameMeasurer = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+// Script timing data we want to track
+var LongAnimationFrameMeasurer = exports.LongAnimationFrameMeasurer = /*#__PURE__*/function () {
+  function LongAnimationFrameMeasurer(options) {
+    var _this = this;
+    (0, _classCallCheck2.default)(this, LongAnimationFrameMeasurer);
+    (0, _defineProperty2.default)(this, "longestScriptTimings", []);
+    (0, _defineProperty2.default)(this, "minimumIndex", -1);
+    (0, _defineProperty2.default)(this, "minimumDuration", Infinity);
+    this.options = options;
+    this.paused = options.insmSession.insm.runningHeavyTasks.size !== 0;
+    if (PerformanceObserver.supportedEntryTypes.includes('long-animation-frame')) {
+      this.observer = new PerformanceObserver(function (list) {
+        if (!_this.paused) {
+          // only handle batches when tracking is not paused
+          _this.handleBatch(list.getEntries());
+        }
+      });
+      this.observer.observe({
+        type: 'long-animation-frame',
+        buffered: options.initial
+      });
+    }
+  }
+  return (0, _createClass2.default)(LongAnimationFrameMeasurer, [{
+    key: "handleBatch",
+    value: function handleBatch(batch) {
+      for (var batchIndex = 0; batchIndex < batch.length; batchIndex++) {
+        var animationFrame = batch[batchIndex];
+
+        // Only process frames that exceed the reporting threshold
+        if (animationFrame.duration < this.options.reportingThreshold) {
+          continue;
+        }
+
+        // Process all scripts in this long animation frame
+        if (animationFrame.scripts && animationFrame.scripts.length > 0) {
+          var _iterator = _createForOfIteratorHelper(animationFrame.scripts),
+            _step;
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var script = _step.value;
+              this.processScript(script, animationFrame);
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+        }
+      }
+    }
+  }, {
+    key: "createScriptTiming",
+    value: function createScriptTiming(script, animationFrame) {
+      return {
+        duration: script.duration,
+        forcedStyleAndLayoutDuration: script.forcedStyleAndLayoutDuration,
+        invoker: script.invoker,
+        invokerType: script.invokerType,
+        sourceCharPosition: script.sourceCharPosition,
+        sourceFunctionName: script.sourceFunctionName,
+        sourceURL: script.sourceURL,
+        features: Array.from(this.options.insmSession.runningFeatures),
+        afDuration: animationFrame.duration
+      };
+    }
+  }, {
+    key: "processScript",
+    value: function processScript(script, animationFrame) {
+      var scriptDuration = script.duration;
+      var len = this.longestScriptTimings.length;
+
+      // Not yet at capacity: append and update min tracking incrementally
+      if (len < this.options.limit) {
+        var _scriptTiming = this.createScriptTiming(script, animationFrame);
+        this.longestScriptTimings[len] = _scriptTiming;
+        if (len === 0 || scriptDuration < this.minimumDuration) {
+          this.minimumDuration = scriptDuration;
+          this.minimumIndex = len;
+        }
+        return;
+      }
+
+      // At capacity: only do work if we beat the current min
+      if (scriptDuration <= this.minimumDuration) {
+        return;
+      }
+      var scriptTiming = this.createScriptTiming(script, animationFrame);
+
+      // Replace the current min
+      this.longestScriptTimings[this.minimumIndex] = scriptTiming;
+
+      // Find new minimum
+      var newMinimumIndex = 0;
+      var newMinimumDuration = this.longestScriptTimings[0].duration;
+      for (var i = 1; i < this.options.limit; i++) {
+        if (this.longestScriptTimings[i].duration < newMinimumDuration) {
+          newMinimumIndex = i;
+          newMinimumDuration = this.longestScriptTimings[i].duration;
+        }
+      }
+
+      // Update the min tracking
+      this.minimumIndex = newMinimumIndex;
+      this.minimumDuration = newMinimumDuration;
+    }
+
+    /**
+     * Pauses tracking
+     */
+  }, {
+    key: "pause",
+    value: function pause() {
+      this.paused = true;
+    }
+
+    /**
+     * Resumes tracking
+     */
+  }, {
+    key: "resume",
+    value: function resume() {
+      this.paused = false;
+    }
+
+    /**
+     * Returns the current tracked longest script timings sorted by duration
+     */
+  }, {
+    key: "current",
+    get: function get() {
+      var copy = this.longestScriptTimings.slice();
+      copy.sort(function (a, b) {
+        return b.duration - a.duration;
+      });
+      return copy;
+    }
+
+    /**
+     * Cleans up the performance tracking (tracking cannot be resumed following this).
+     */
+  }, {
+    key: "cleanup",
+    value: function cleanup() {
+      var _this$observer;
+      (_this$observer = this.observer) === null || _this$observer === void 0 || _this$observer.disconnect();
+    }
+  }]);
+}(); // Based on https://github.com/GoogleChrome/web-vitals/blob/1b872cf5f2159e8ace0e98d55d8eb54fb09adfbe/src/types.ts#L129
+// exported for use in test file
+// Based on https://github.com/GoogleChrome/web-vitals/blob/1b872cf5f2159e8ace0e98d55d8eb54fb09adfbe/src/types.ts#L129

package/dist/es2019/index.js

@@ -9,8 +9,6 @@ export function init(options) {
 }
 function insmInitialised() {
   if (!initialisedInsm) {
-    // eslint-disable-next-line no-console
-    console.error('INSM used when not initialised');
     return false;
   }
   return true;
@@ -35,6 +33,11 @@ export const insm = {
       initialisedInsm.start(experienceKey, experienceProperties);
     }
   },
+  overrideExperienceKey(experienceKey) {
+    if (insmInitialised()) {
+      initialisedInsm.overrideExperienceKey(experienceKey);
+    }
+  },
   stopEarly(reasonKey, description) {
     if (insmInitialised()) {
       initialisedInsm.stopEarly(reasonKey, description);

package/dist/es2019/insm-period.js

@@ -1,6 +1,6 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 /* eslint-disable @repo/internal/dom-events/no-unsafe-event-listeners */
-
+import { fg } from '@atlaskit/platform-feature-flags';
 export class PeriodTracking {
   constructor(session) {
     _defineProperty(this, "periodMeasurements", {
@@ -106,6 +106,24 @@ export class PeriodTracking {
   }
   get endResults() {
     this.changePeriodAndTrackLast(this.state);
+    if (fg('cc_editor_insm_fix_attributes')) {
+      return {
+        active: {
+          features: Array.from(this.periodMeasurements.active.features),
+          heavyTasks: Array.from(this.periodMeasurements.active.heavyTasks),
+          measurements: this.periodMeasurements.active.measurements,
+          duration: this.periodMeasurements.active.duration,
+          count: this.periodMeasurements.active.count
+        },
+        inactive: {
+          features: Array.from(this.periodMeasurements.inactive.features),
+          heavyTasks: Array.from(this.periodMeasurements.inactive.heavyTasks),
+          measurements: this.periodMeasurements.inactive.measurements,
+          duration: this.periodMeasurements.inactive.duration,
+          count: this.periodMeasurements.inactive.count
+        }
+      };
+    }
     return this.periodMeasurements;
   }
   setupActiveStartInteractionListeners() {