@webex/internal-plugin-metrics 3.12.0-next.34 → 3.12.0-next.36

package/dist/call-diagnostic/call-diagnostic-metrics-latencies.js

@@ -1,6 +1,11 @@
 "use strict";
 
 var _Reflect$construct = require("@babel/runtime-corejs2/core-js/reflect/construct");
+var _Object$keys = require("@babel/runtime-corejs2/core-js/object/keys");
+var _Object$getOwnPropertySymbols = require("@babel/runtime-corejs2/core-js/object/get-own-property-symbols");
+var _Object$getOwnPropertyDescriptor = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptor");
+var _Object$getOwnPropertyDescriptors = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptors");
+var _Object$defineProperties = require("@babel/runtime-corejs2/core-js/object/define-properties");
 var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
 var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault");
 _Object$defineProperty(exports, "__esModule", {
@@ -8,6 +13,7 @@ _Object$defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _map = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/map"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/toConsumableArray"));
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/classCallCheck"));
 var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/createClass"));
 var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/possibleConstructorReturn"));
@@ -16,9 +22,17 @@ var _inherits2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
 var _webexCore = require("@webex/webex-core");
 var _lodash = require("lodash");
+var _metrics = require("../metrics.types");
+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 _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? _Reflect$construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
 function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(_Reflect$construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); } /* eslint-disable class-methods-use-this */ /* eslint-disable valid-jsdoc */
 // we only care about client event and feature event for now
+/**
+ * Container for the latencies tracked for a single meeting. Locus sync is currently the only
+ * meeting-specific latency we track, but this wrapper lets us add other latency records in the
+ * future without changing the shape of `meetingLatencies`.
+ */
 /**
  * @description Helper class to store latencies timestamp and to calculate various latencies for CA.
  * @exports
@@ -37,11 +51,23 @@ var CallDiagnosticLatencies = exports.default = /*#__PURE__*/function (_WebexPlu
     _this = _callSuper(this, CallDiagnosticLatencies, [].concat(args));
     (0, _defineProperty2.default)(_this, "latencyTimestamps", void 0);
     (0, _defineProperty2.default)(_this, "precomputedLatencies", void 0);
+    (0, _defineProperty2.default)(_this, "meetingLatencies", void 0);
     // meetingId that the current latencies are for
     (0, _defineProperty2.default)(_this, "meetingId", void 0);
     (0, _defineProperty2.default)(_this, "MAX_INTEGER", 2147483647);
+    // Aligned with UCF desktop (MekleFlowSyncMetricsTracker::kSleepWakeSkewThresholdMs): if any
+    // measured Locus sync segment exceeds this threshold the record is assumed to be corrupted by a
+    // clock jump (sleep/wake) and is discarded instead of being reported.
+    (0, _defineProperty2.default)(_this, "LOCUS_SYNC_SKEW_THRESHOLD_MS", 10 * 60 * 1000);
+    // Incomplete Locus sync records (missing the /sync response and/or the LLM message) are kept for
+    // this long so a late milestone can still complete them, then pruned as stale.
+    (0, _defineProperty2.default)(_this, "LOCUS_SYNC_PENDING_RECORD_TTL_MS", 5 * 60 * 1000);
+    // Safety cap on the number of records kept per meeting + dataset, to bound memory if syncs churn
+    // faster than the TTL can clean them up.
+    (0, _defineProperty2.default)(_this, "LOCUS_SYNC_MAX_RECORDS_PER_DATASET", 20);
     _this.latencyTimestamps = new _map.default();
     _this.precomputedLatencies = new _map.default();
+    _this.meetingLatencies = new _map.default();
     return _this;
   }
 
@@ -54,6 +80,502 @@ var CallDiagnosticLatencies = exports.default = /*#__PURE__*/function (_WebexPlu
     value: function clearTimestamps() {
       this.latencyTimestamps.clear();
       this.precomputedLatencies.clear();
+      this.meetingLatencies.clear();
+    }
+
+    /**
+     * Clear tracked Locus sync latency state for a dataset.
+     *
+     * When a `trackingId` is supplied only the single record matching it is dropped, mirroring the
+     * native client which discards the individual in-progress record on a sync error (by syncId).
+     * When no `trackingId` is supplied every record for the dataset is dropped (legacy behavior).
+     *
+     * @param dataSetName dataset name
+     * @param meetingId meeting id
+     * @param trackingId optional sync tracking id to drop a single record instead of the whole dataset
+     */
+  }, {
+    key: "clearLocusSyncLatency",
+    value: function clearLocusSyncLatency(dataSetName, meetingId, trackingId) {
+      var records = this.meetingLatencies.get(meetingId);
+      if (!records) {
+        return;
+      }
+      var remainingRecords = trackingId ? records.filter(function (record) {
+        return record.locusSync.trackingId !== trackingId;
+      }) : records.filter(function (record) {
+        return record.locusSync.dataSetName !== dataSetName;
+      });
+      this.setMeetingLatencyRecords(meetingId, remainingRecords);
+    }
+
+    /**
+     * Calculates Locus sync latency values from stored milestone timestamps.
+     * @param meetingId meeting id
+     * @param trackingId sync tracking id used to match the record
+     * @returns sync latency metrics
+     */
+  }, {
+    key: "getLocusSyncLatency",
+    value: function getLocusSyncLatency(meetingId, trackingId) {
+      var _this$getDiffBetweenL,
+        _this$getDiffBetweenL2,
+        _this2 = this;
+      if (!trackingId) {
+        return undefined;
+      }
+      var record = this.getLocusSyncLatencyRecord(meetingId, trackingId);
+      if (!record) {
+        return undefined;
+      }
+
+      // Some sync flows skip the /hashtree request, for example single-leaf data sets or cases
+      // where we already know which leaves to sync. Treat the missing hashtree segment as 0,
+      // while still requiring the sync request/response/message milestones below.
+      var hashtreePrepTime = (_this$getDiffBetweenL = this.getDiffBetweenLocusSyncTimestamps(record, 'syncStart', 'hashTreeRequest')) !== null && _this$getDiffBetweenL !== void 0 ? _this$getDiffBetweenL : 0;
+      var hashtreeResponseTime = (_this$getDiffBetweenL2 = this.getDiffBetweenLocusSyncTimestamps(record, 'hashTreeRequest', 'hashTreeResponse')) !== null && _this$getDiffBetweenL2 !== void 0 ? _this$getDiffBetweenL2 : 0;
+      var syncPrepStart = this.getLocusSyncPrepStart(record);
+      var syncPrepTime = this.getDiffBetweenLocusSyncTimestamps(record, syncPrepStart, 'syncRequest');
+      var syncResponseTime = this.getDiffBetweenLocusSyncTimestamps(record, 'syncRequest', 'syncResponse');
+      // Aligned with UCF: syncMessageReceiveTime is measured from the sync request start (not the
+      // sync response), i.e. how long after we asked Locus to sync the resulting state update arrived.
+      var syncMessageReceiveTime = this.getDiffBetweenLocusSyncTimestamps(record, 'syncRequest', 'messageReceived');
+      var totalTimeFromMessageReceived = this.getDiffBetweenLocusSyncTimestamps(record, 'syncStart', 'messageReceived');
+      var totalTimeFromSyncResponse = this.getDiffBetweenLocusSyncTimestamps(record, 'syncStart', 'syncResponse');
+
+      // messageReceived can occasionally be out of order due to race conditions relative to the
+      // /sync response. Use the larger of the two so totalTime is never less than syncStart->syncResponse.
+      var totalTime = typeof totalTimeFromMessageReceived === 'number' && typeof totalTimeFromSyncResponse === 'number' ? Math.max(totalTimeFromMessageReceived, totalTimeFromSyncResponse) : totalTimeFromMessageReceived !== null && totalTimeFromMessageReceived !== void 0 ? totalTimeFromMessageReceived : totalTimeFromSyncResponse;
+      if (typeof syncPrepTime !== 'number' || typeof totalTime !== 'number') {
+        return undefined;
+      }
+
+      // Aligned with UCF desktop (MekleFlowSyncMetricsTracker kSleepWakeSkewThresholdMs): if any
+      // individual segment is larger than the skew threshold the timestamps were almost certainly
+      // distorted by a clock jump (device sleep/wake), so discard the whole record.
+      var skewedSegment = [record.randomBackoffTime, hashtreePrepTime, hashtreeResponseTime, syncPrepTime, syncResponseTime, syncMessageReceiveTime, totalTime].some(function (segment) {
+        return typeof segment === 'number' && segment > _this2.LOCUS_SYNC_SKEW_THRESHOLD_MS;
+      });
+      if (skewedSegment) {
+        return undefined;
+      }
+
+      // Emit whenever at least one measured segment is non-zero. The LLM broadcast itself is gated
+      // in completeLocusSyncLatency(); this only guards against an all-zero (unmeasurable) record.
+      var hasMeaningfulSegment = hashtreeResponseTime > 0 || typeof syncResponseTime === 'number' && syncResponseTime > 0 || typeof syncMessageReceiveTime === 'number' && syncMessageReceiveTime > 0;
+      if (!hasMeaningfulSegment) {
+        return undefined;
+      }
+      return _objectSpread(_objectSpread(_objectSpread({
+        randomBackoffTime: this.getClampedLocusSyncLatency(record.randomBackoffTime),
+        hashtreePrepTime: hashtreePrepTime,
+        hashtreeResponseTime: hashtreeResponseTime,
+        syncPrepTime: syncPrepTime
+      }, typeof syncResponseTime === 'number' ? {
+        syncResponseTime: syncResponseTime
+      } : {}), typeof syncMessageReceiveTime === 'number' ? {
+        syncMessageReceiveTime: syncMessageReceiveTime
+      } : {}), {}, {
+        totalTime: totalTime
+      });
+    }
+
+    /**
+     * Records the time the LLM state-update message for a Locus sync arrived. This is the milestone
+     * that gates the client.locus.sync.complete metric: the metric is emitted only for flows where
+     * the update came over LLM (aligned with the agreed requirement that body/http-only syncs do not
+     * emit). The record is matched by meeting id + tracking id, regardless of which other milestones
+     * are present yet, so the real arrival time is captured even if the /sync response has not landed.
+     * @param meetingId meeting id
+     * @param trackingId sync tracking id used to match the pending record
+     * @returns void
+     */
+  }, {
+    key: "recordLocusSyncMessageReceived",
+    value: function recordLocusSyncMessageReceived(meetingId, trackingId) {
+      if (!trackingId) {
+        return;
+      }
+      var record = this.getLocusSyncLatencyRecord(meetingId, trackingId);
+      if (record && typeof record.messageReceived !== 'number') {
+        record.messageReceived = new Date().getTime();
+        var records = this.meetingLatencies.get(meetingId);
+        if (records) {
+          this.setMeetingLatencyRecords(meetingId, records, {
+            changedRecord: record
+          });
+        }
+      }
+    }
+
+    /**
+     * Complete and remove the Locus sync latency record for a meeting + tracking id.
+     *
+     * Both milestones are required, in any arrival order: the metric is emitted only once BOTH the
+     * matching LLM broadcast (messageReceived) AND the /sync response have arrived. The LLM broadcast
+     * confirms the client that issued the /sync received the resulting state update for its tracking
+     * id (so sync cancel, or a sync storm where the final broadcast echoed another client's tracking
+     * id, never emit); the /sync response is always waited for too, since the LLM message can arrive
+     * before the HTTP response. If either milestone is missing the record is kept so the other can
+     * still arrive; it is only consumed when the metric is actually emitted.
+     * @param meetingId meeting id
+     * @param trackingId sync tracking id used to match the pending record
+     * @returns completed sync latency metric payload, or undefined when not completed
+     */
+  }, {
+    key: "completeLocusSyncLatency",
+    value: function completeLocusSyncLatency(meetingId, trackingId) {
+      if (!trackingId) {
+        return undefined;
+      }
+      var record = this.getLocusSyncLatencyRecord(meetingId, trackingId);
+      if (!record) {
+        return undefined;
+      }
+      var hasMessageReceived = typeof record.messageReceived === 'number';
+      var hasSyncResponse = typeof record.syncResponse === 'number';
+
+      // Wait until both milestones are present before emitting. The LLM broadcast and the /sync
+      // response can arrive in either order, so we keep the record until the second one lands.
+      if (!hasMessageReceived || !hasSyncResponse) {
+        return undefined;
+      }
+      var syncLatency = this.getLocusSyncLatency(meetingId, trackingId);
+      this.removeLocusSyncLatencyRecord(meetingId, trackingId);
+      if (!syncLatency) {
+        return undefined;
+      }
+      var completed = {
+        dataSet: record.dataSetName,
+        syncLatency: syncLatency
+      };
+      return completed;
+    }
+
+    /**
+     * Helper to calculate end - start for Locus sync milestones.
+     * @param record tracked milestone timestamps
+     * @param a start milestone
+     * @param b end milestone
+     * @returns latency
+     */
+  }, {
+    key: "getDiffBetweenLocusSyncTimestamps",
+    value: function getDiffBetweenLocusSyncTimestamps(record, a, b) {
+      var start = record[a];
+      var end = record[b];
+      if (typeof start !== 'number' || typeof end !== 'number') {
+        return undefined;
+      }
+      return this.getClampedLocusSyncLatency(end - start);
+    }
+
+    /**
+     * Get the timestamp that starts the sync prep segment.
+     * @param record tracked milestone timestamps
+     * @returns sync prep start milestone
+     */
+  }, {
+    key: "getLocusSyncPrepStart",
+    value: function getLocusSyncPrepStart(record) {
+      return typeof record.hashTreeResponse === 'number' ? 'hashTreeResponse' : 'syncStart';
+    }
+
+    /**
+     * Round and clamp Locus sync latency values.
+     * @param latency latency value
+     * @returns rounded latency
+     */
+  }, {
+    key: "getClampedLocusSyncLatency",
+    value: function getClampedLocusSyncLatency(latency) {
+      return Math.round((0, _lodash.clamp)(latency, 0, this.MAX_INTEGER));
+    }
+
+    /**
+     * Finds a Locus sync latency record for a meeting using a predicate run against each stored
+     * locusSync record.
+     * @param meetingId meeting id
+     * @param predicate matcher run against each locusSync record
+     * @param options.searchFromLatest when true, iterate from the most recently added record first
+     * @returns matching Locus sync latency record
+     */
+  }, {
+    key: "findLocusSyncRecord",
+    value: function findLocusSyncRecord(meetingId, predicate) {
+      var _orderedRecords$find;
+      var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
+        _ref$searchFromLatest = _ref.searchFromLatest,
+        searchFromLatest = _ref$searchFromLatest === void 0 ? false : _ref$searchFromLatest;
+      var records = this.meetingLatencies.get(meetingId);
+      if (!records) {
+        return undefined;
+      }
+      var orderedRecords = searchFromLatest ? (0, _toConsumableArray2.default)(records).reverse() : records;
+      return (_orderedRecords$find = orderedRecords.find(function (record) {
+        return predicate(record.locusSync);
+      })) === null || _orderedRecords$find === void 0 ? void 0 : _orderedRecords$find.locusSync;
+    }
+
+    /**
+     * Get the Locus sync latency record for a meeting and tracking id.
+     * @param meetingId meeting id
+     * @param trackingId /sync response tracking id
+     * @returns matching Locus sync latency record
+     */
+  }, {
+    key: "getLocusSyncLatencyRecord",
+    value: function getLocusSyncLatencyRecord(meetingId, trackingId) {
+      return this.findLocusSyncRecord(meetingId, function (locusSync) {
+        return locusSync.trackingId === trackingId;
+      });
+    }
+
+    /**
+     * Remove the Locus sync latency record for a meeting and tracking id.
+     * @param meetingId meeting id
+     * @param trackingId sync tracking id used to match the record
+     * @returns void
+     */
+  }, {
+    key: "removeLocusSyncLatencyRecord",
+    value: function removeLocusSyncLatencyRecord(meetingId, trackingId) {
+      var records = this.meetingLatencies.get(meetingId);
+      if (!records) {
+        return;
+      }
+      var remainingRecords = records.filter(function (_ref2) {
+        var locusSync = _ref2.locusSync;
+        return locusSync.trackingId !== trackingId;
+      });
+      this.setMeetingLatencyRecords(meetingId, remainingRecords);
+    }
+
+    /**
+     * Prune stale never-completed Locus sync latency records for the same dataset as the record that
+     * just changed. Records are dropped when they have been pending longer than the TTL, or to keep
+     * the number of records per dataset under the safety cap (oldest pending candidates first).
+     * @param records current records for the meeting
+     * @param changedRecord the record that was just updated, used as the reference point
+     * @returns the records to keep
+     */
+  }, {
+    key: "pruneStaleLocusSyncLatencyRecords",
+    value: function pruneStaleLocusSyncLatencyRecords(records, changedRecord) {
+      var _this3 = this;
+      var currentTimestamp = this.getLatestLocusSyncTimestamp(changedRecord);
+      if (typeof currentTimestamp !== 'number') {
+        return records;
+      }
+
+      // A record is only a cleanup candidate when it belongs to the same dataset as the record that
+      // just changed, is not that record itself, and has never completed. Everything else is kept.
+      var isPrunableCandidate = function isPrunableCandidate(locusSync) {
+        if (locusSync.dataSetName !== changedRecord.dataSetName) {
+          return false;
+        }
+        if (changedRecord.trackingId && locusSync.trackingId === changedRecord.trackingId) {
+          return false;
+        }
+        var hasCompleted = typeof locusSync.syncResponse === 'number' && typeof locusSync.messageReceived === 'number';
+        return !hasCompleted;
+      };
+
+      // 1) Drop candidates that have been pending longer than the TTL.
+      var recordsAfterTtl = records.filter(function (_ref3) {
+        var locusSync = _ref3.locusSync;
+        if (!isPrunableCandidate(locusSync)) {
+          return true;
+        }
+        var lastTimestamp = _this3.getLatestLocusSyncTimestamp(locusSync);
+        if (typeof lastTimestamp !== 'number') {
+          return true;
+        }
+        return currentTimestamp - lastTimestamp < _this3.LOCUS_SYNC_PENDING_RECORD_TTL_MS;
+      });
+
+      // 2) Cap the number of records kept per dataset, dropping the oldest pending candidates first.
+      var overflowCount = Math.max(0, recordsAfterTtl.filter(function (_ref4) {
+        var locusSync = _ref4.locusSync;
+        return locusSync.dataSetName === changedRecord.dataSetName;
+      }).length - this.LOCUS_SYNC_MAX_RECORDS_PER_DATASET);
+      if (overflowCount === 0) {
+        return recordsAfterTtl;
+      }
+      return recordsAfterTtl.filter(function (_ref5) {
+        var locusSync = _ref5.locusSync;
+        if (overflowCount <= 0 || !isPrunableCandidate(locusSync)) {
+          return true;
+        }
+        overflowCount -= 1;
+        return false;
+      });
+    }
+
+    /**
+     * Get the most recent milestone timestamp stored on a Locus sync latency record, checking
+     * milestones from latest to earliest so the newest available one is returned.
+     * @param record tracked milestone timestamps
+     * @returns latest milestone timestamp, or undefined when none are set
+     */
+  }, {
+    key: "getLatestLocusSyncTimestamp",
+    value: function getLatestLocusSyncTimestamp(record) {
+      var _ref6, _ref7, _ref8, _ref9, _record$messageReceiv;
+      return (_ref6 = (_ref7 = (_ref8 = (_ref9 = (_record$messageReceiv = record.messageReceived) !== null && _record$messageReceiv !== void 0 ? _record$messageReceiv : record.syncResponse) !== null && _ref9 !== void 0 ? _ref9 : record.syncRequest) !== null && _ref8 !== void 0 ? _ref8 : record.hashTreeResponse) !== null && _ref7 !== void 0 ? _ref7 : record.hashTreeRequest) !== null && _ref6 !== void 0 ? _ref6 : record.syncStart;
+    }
+
+    /**
+     * Persist the Locus sync latency records for a meeting, deleting the meeting entry when no
+     * records remain. When pruneOptions is provided, stale records are pruned before saving.
+     * @param meetingId meeting id
+     * @param records records to save
+     * @param pruneOptions when provided, triggers stale record pruning relative to changedRecord
+     * @returns void
+     */
+  }, {
+    key: "setMeetingLatencyRecords",
+    value: function setMeetingLatencyRecords(meetingId, records, pruneOptions) {
+      var recordsToSave = pruneOptions ? this.pruneStaleLocusSyncLatencyRecords(records, pruneOptions.changedRecord) : records;
+      if (recordsToSave.length > 0) {
+        this.meetingLatencies.set(meetingId, recordsToSave);
+      } else {
+        this.meetingLatencies.delete(meetingId);
+      }
+    }
+
+    /**
+     * Get the latest Locus sync latency record waiting for sync.start.
+     * @param meetingId meeting id
+     * @param dataSetName dataset name
+     * @returns latest pending Locus sync latency record
+     */
+  }, {
+    key: "getLatestPendingLocusSyncLatencyRecord",
+    value: function getLatestPendingLocusSyncLatencyRecord(meetingId, dataSetName) {
+      return this.findLocusSyncRecord(meetingId, function (locusSync) {
+        return locusSync.dataSetName === dataSetName && locusSync.syncStart === undefined;
+      }, {
+        searchFromLatest: true
+      });
+    }
+
+    /**
+     * Store random backoff latency for the current or next Locus sync latency record.
+     * @param meetingId meeting id
+     * @param dataSetName dataset name
+     * @param randomBackoffTime random backoff latency value
+     * @returns void
+     */
+  }, {
+    key: "saveLocusSyncBackoffLatency",
+    value: function saveLocusSyncBackoffLatency(_ref0) {
+      var _this$meetingLatencie;
+      var meetingId = _ref0.meetingId,
+        dataSetName = _ref0.dataSetName,
+        randomBackoffTime = _ref0.randomBackoffTime;
+      var pendingRecord = this.getLatestPendingLocusSyncLatencyRecord(meetingId, dataSetName);
+      if (pendingRecord) {
+        pendingRecord.randomBackoffTime = randomBackoffTime;
+        return;
+      }
+      var records = (_this$meetingLatencie = this.meetingLatencies.get(meetingId)) !== null && _this$meetingLatencie !== void 0 ? _this$meetingLatencie : [];
+      records.push({
+        locusSync: {
+          meetingId: meetingId,
+          dataSetName: dataSetName,
+          randomBackoffTime: randomBackoffTime
+        }
+      });
+      this.meetingLatencies.set(meetingId, records);
+    }
+
+    /**
+     * Checks if metric event name is a Locus sync latency milestone.
+     * @param key event name
+     * @returns whether event is Locus sync latency milestone
+     */
+  }, {
+    key: "isLocusSyncLatencyEvent",
+    value: function isLocusSyncLatencyEvent(key) {
+      return _metrics.LOCUS_SYNC_LATENCY_EVENT_NAMES.includes(key);
+    }
+
+    /**
+     * Stores a Locus sync latency milestone timestamp.
+     * @param options options
+     */
+  }, {
+    key: "saveLocusSyncLatencyTimestamp",
+    value: function saveLocusSyncLatencyTimestamp(_ref1) {
+      var _this$meetingLatencie4;
+      var meetingId = _ref1.meetingId,
+        dataSetName = _ref1.dataSetName,
+        key = _ref1.key,
+        value = _ref1.value,
+        trackingId = _ref1.trackingId;
+      if (!trackingId) {
+        // @ts-ignore
+        this.webex.logger.warn("CallDiagnosticLatencies: saveLocusSyncLatencyTimestamp called without a trackingId for key \"".concat(key, "\"; skipping Locus sync milestone"));
+        return;
+      }
+      if (key === 'internal.client.locus.sync.start') {
+        var _this$meetingLatencie3;
+        var pendingRecord = this.getLatestPendingLocusSyncLatencyRecord(meetingId, dataSetName);
+        if (pendingRecord) {
+          var _this$meetingLatencie2;
+          pendingRecord.trackingId = trackingId;
+          pendingRecord.syncStart = value;
+          this.setMeetingLatencyRecords(meetingId, (_this$meetingLatencie2 = this.meetingLatencies.get(meetingId)) !== null && _this$meetingLatencie2 !== void 0 ? _this$meetingLatencie2 : [], {
+            changedRecord: pendingRecord
+          });
+          return;
+        }
+        var records = (_this$meetingLatencie3 = this.meetingLatencies.get(meetingId)) !== null && _this$meetingLatencie3 !== void 0 ? _this$meetingLatencie3 : [];
+        records.push({
+          locusSync: {
+            meetingId: meetingId,
+            dataSetName: dataSetName,
+            randomBackoffTime: 0,
+            trackingId: trackingId,
+            syncStart: value
+          }
+        });
+        this.setMeetingLatencyRecords(meetingId, records, {
+          changedRecord: records[records.length - 1].locusSync
+        });
+        return;
+      }
+
+      // Every sync milestone after sync.start is stamped with the same tracking id that was
+      // generated up-front and forced onto the /sync request, so the record is located by
+      // meeting id + tracking id.
+      var record = this.getLocusSyncLatencyRecord(meetingId, trackingId);
+      if (!record) {
+        return;
+      }
+      switch (key) {
+        case 'internal.client.locus.hashtree.request':
+          record.hashTreeRequest = value;
+          break;
+        case 'internal.client.locus.hashtree.response':
+          record.hashTreeResponse = value;
+          break;
+        case 'internal.client.locus.sync.request':
+          record.syncRequest = value;
+          break;
+        case 'internal.client.locus.sync.response':
+          record.syncResponse = value;
+          break;
+        case 'internal.client.locus.sync.message.received':
+          record.messageReceived = value;
+          break;
+        default:
+          break;
+      }
+      this.setMeetingLatencyRecords(meetingId, (_this$meetingLatencie4 = this.meetingLatencies.get(meetingId)) !== null && _this$meetingLatencie4 !== void 0 ? _this$meetingLatencie4 : [], {
+        changedRecord: record
+      });
     }
 
     /**
@@ -90,17 +612,28 @@ var CallDiagnosticLatencies = exports.default = /*#__PURE__*/function (_WebexPlu
      */
   }, {
     key: "saveTimestamp",
-    value: function saveTimestamp(_ref) {
-      var key = _ref.key,
-        _ref$value = _ref.value,
-        value = _ref$value === void 0 ? new Date().getTime() : _ref$value,
-        _ref$options = _ref.options,
-        options = _ref$options === void 0 ? {} : _ref$options;
+    value: function saveTimestamp(_ref10) {
+      var key = _ref10.key,
+        _ref10$value = _ref10.value,
+        value = _ref10$value === void 0 ? new Date().getTime() : _ref10$value,
+        _ref10$options = _ref10.options,
+        options = _ref10$options === void 0 ? {} : _ref10$options;
       // save the meetingId so we can use the meeting object in latency calculations if needed
       var meetingId = options.meetingId;
       if (meetingId) {
         this.setMeetingId(meetingId);
       }
+      if (this.isLocusSyncLatencyEvent(key) && options.dataSetName && options.meetingId) {
+        this.saveLocusSyncLatencyTimestamp({
+          meetingId: options.meetingId,
+          dataSetName: options.dataSetName,
+          key: key,
+          value: value,
+          trackingId: options.trackingId
+        });
+        return;
+      }
+
       // for some events we're only interested in the first timestamp not last
       // as these events can happen multiple times
       if (key === 'client.media.rx.start' || key === 'client.media.tx.start' || key === 'internal.client.meetinginfo.request' || key === 'internal.client.meetinginfo.response' || key === 'client.media-engine.remote-sdp-received') {
@@ -118,14 +651,35 @@ var CallDiagnosticLatencies = exports.default = /*#__PURE__*/function (_WebexPlu
      * Store precomputed latency value
      * @param key - key
      * @param value - value
-     * @param accumulate - when it is true, it overwrites existing value with sum of the current value and the new measurement otherwise just store the new measurement
+     * @param options - store options (a legacy boolean `accumulate` flag is also accepted)
+     * @param options.accumulate - when it is true, it overwrites existing value with sum of the current value and the new measurement otherwise just store the new measurement
+     * @param options.meetingId - meeting id, only used for Locus sync latency records
+     * @param options.dataSetName - dataset name, only used for Locus sync latency records
      * @throws
      * @returns
      */
   }, {
     key: "saveLatency",
     value: function saveLatency(key, value) {
-      var accumulate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      // Older (untyped) callers may still pass a boolean `accumulate` as the third argument
+      // (saveLatency(key, value, true)). Normalize it to the options object before destructuring,
+      // otherwise accumulation is silently lost and legacy SDK/plugin consumers underreport latencies.
+      var normalizedOptions = typeof options === 'boolean' ? {
+        accumulate: options
+      } : options;
+      var _normalizedOptions$ac = normalizedOptions.accumulate,
+        accumulate = _normalizedOptions$ac === void 0 ? false : _normalizedOptions$ac,
+        meetingId = normalizedOptions.meetingId,
+        dataSetName = normalizedOptions.dataSetName;
+      if (key === 'internal.client.locus.sync.random.backoff' && meetingId && dataSetName) {
+        this.saveLocusSyncBackoffLatency({
+          meetingId: meetingId,
+          dataSetName: dataSetName,
+          randomBackoffTime: value
+        });
+        return;
+      }
       var existingValue = accumulate ? this.precomputedLatencies.get(key) || 0 : 0;
       this.precomputedLatencies.set(key, value + existingValue);
     }
@@ -140,11 +694,13 @@ var CallDiagnosticLatencies = exports.default = /*#__PURE__*/function (_WebexPlu
   }, {
     key: "measureLatency",
     value: function measureLatency(callback, key) {
-      var _this2 = this;
+      var _this4 = this;
       var accumulate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
       var start = performance.now();
       return callback().finally(function () {
-        _this2.saveLatency(key, performance.now() - start, accumulate);
+        _this4.saveLatency(key, performance.now() - start, {
+          accumulate: accumulate
+        });
       });
     }
 
@@ -180,11 +736,11 @@ var CallDiagnosticLatencies = exports.default = /*#__PURE__*/function (_WebexPlu
         return undefined;
       }
       var diff = end - start;
-      var _ref2 = clampValues || {},
-        _ref2$minimum = _ref2.minimum,
-        minimum = _ref2$minimum === void 0 ? 0 : _ref2$minimum,
-        _ref2$maximum = _ref2.maximum,
-        maximum = _ref2$maximum === void 0 ? this.MAX_INTEGER : _ref2$maximum;
+      var _ref11 = clampValues || {},
+        _ref11$minimum = _ref11.minimum,
+        minimum = _ref11$minimum === void 0 ? 0 : _ref11$minimum,
+        _ref11$maximum = _ref11.maximum,
+        maximum = _ref11$maximum === void 0 ? this.MAX_INTEGER : _ref11$maximum;
       return (0, _lodash.clamp)(diff, minimum, maximum);
     }