@fluid-experimental/tree 1.0.0 → 1.1.0-76254

package/lib/id-compressor/IdCompressor.js

@@ -2,7 +2,6 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-/* eslint-disable @typescript-eslint/restrict-plus-operands */
 import BTree from 'sorted-btree';
 import { assert, hasLength, assertNotUndefined, compareFiniteNumbers, compareFiniteNumbersReversed, compareMaps, compareStrings, fail, getOrCreate, setPropertyIfDefined, } from '../Common';
 import { assertIsStableId, assertIsUuidString, isStableId } from '../UuidUtilities';
@@ -110,9 +109,10 @@ export class IdCompressor {
      * this compressor will generate its own. An `AttributionId` is an `UuidString` which may be validated via
      * {@link isUuidString} or generated via {@link generateStableId}.
      */
-    constructor(localSessionId, reservedIdCount, attributionId) {
+    constructor(localSessionId, reservedIdCount, attributionId, logger) {
         this.localSessionId = localSessionId;
         this.reservedIdCount = reservedIdCount;
+        this.logger = logger;
         /**
          * Trivially reach consensus on default cluster size and reserved IDs.
          * These initial values must *NOT* change without careful consideration to compatibility.
@@ -321,7 +321,7 @@ export class IdCompressor {
      * @param range - the range of session-local IDs to finalize.
      */
     finalizeCreationRange(range) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         const { sessionId, attributionId } = range;
         const isLocal = sessionId === this.localSessionId;
         const session = (_a = this.sessions.get(sessionId)) !== null && _a !== void 0 ? _a : this.createSession(sessionId, attributionId);
@@ -342,6 +342,7 @@ export class IdCompressor {
         // The total number of session-local IDs to finalize
         const finalizeCount = normalizedLastFinalizedLocal - newLastFinalizedLocal;
         assert(finalizeCount >= 1, 'Cannot finalize an empty range.');
+        let eagerFinalIdCount = 0;
         let initialClusterCount = 0;
         let remainingCount = finalizeCount;
         let newBaseUuid;
@@ -352,6 +353,7 @@ export class IdCompressor {
                     Math.min(currentCluster.count + finalizeCount, currentCluster.capacity) -
                     1);
                 if (lastFinalInCluster > lastKnownFinal) {
+                    eagerFinalIdCount = lastFinalInCluster - (lastKnownFinal + 1);
                     this.sessionIdNormalizer.addFinalIds((lastKnownFinal + 1), lastFinalInCluster, currentCluster);
                 }
             }
@@ -367,6 +369,7 @@ export class IdCompressor {
                     // The cluster is full but is the last in the list of clusters.
                     // This allows it to be expanded instead of allocating a new one.
                     const expansionAmount = this.newClusterCapacity + overflow;
+                    const previousCapacity = currentCluster.capacity;
                     currentCluster.capacity += expansionAmount;
                     this.nextClusterBaseFinalId = (this.nextClusterBaseFinalId + expansionAmount);
                     assert(this.nextClusterBaseFinalId < Number.MAX_SAFE_INTEGER, 'The number of allocated final IDs must not exceed the JS maximum safe integer.');
@@ -385,6 +388,13 @@ export class IdCompressor {
                         const lastFinalizedFinal = (currentBaseFinalId + currentCluster.count - 1);
                         const finalPivot = (lastFinalizedFinal - overflow + 1);
                         this.sessionIdNormalizer.addFinalIds(finalPivot, lastFinalizedFinal, currentCluster);
+                        (_d = this.logger) === null || _d === void 0 ? void 0 : _d.sendTelemetryEvent({
+                            eventName: 'IdCompressor:ClusterExpansion',
+                            sessionId: this.localSessionId,
+                            previousCapacity,
+                            newCapacity: currentCluster.capacity,
+                            overflow,
+                        });
                     }
                 }
             }
@@ -394,11 +404,19 @@ export class IdCompressor {
                 newBaseUuid = incrementUuid(currentCluster.baseUuid, currentCluster.capacity);
                 currentCluster.count += remainingCapacity;
                 remainingCount -= remainingCapacity;
+                (_e = this.logger) === null || _e === void 0 ? void 0 : _e.sendTelemetryEvent({
+                    eventName: 'IdCompressor:OverfilledCluster',
+                    sessionId: this.localSessionId,
+                });
             }
         }
         else {
             // Session has never made a cluster, form a new one with the session UUID as the baseUuid
             newBaseUuid = session.sessionUuid;
+            (_f = this.logger) === null || _f === void 0 ? void 0 : _f.sendTelemetryEvent({
+                eventName: 'IdCompressor:FirstCluster',
+                sessionId: this.localSessionId,
+            });
         }
         // Finalizing a range results in one of three cases:
         // 1. All local IDs are finalized into a new cluster (because there was either never a cluster for that session, or the current
@@ -419,15 +437,22 @@ export class IdCompressor {
                 fail('Cluster must be filled before another is allocated.');
             }
             newBaseFinalId = this.nextClusterBaseFinalId;
+            const newCapacity = Math.max(this.newClusterCapacity, remainingCount);
             newCluster = {
                 baseUuid: newBaseUuid,
-                capacity: Math.max(this.newClusterCapacity, remainingCount),
+                capacity: newCapacity,
                 count: remainingCount,
                 session,
             };
             const usedCapacity = finalizeCount - remainingCount;
             localIdPivot = (newFirstFinalizedLocal - usedCapacity);
             if (isLocal) {
+                (_g = this.logger) === null || _g === void 0 ? void 0 : _g.sendTelemetryEvent({
+                    eventName: 'IdCompressor:NewCluster',
+                    sessionId: this.localSessionId,
+                    clusterCapacity: newCapacity,
+                    clusterCount: remainingCount,
+                });
                 const lastFinalizedFinal = (newBaseFinalId + newCluster.count - 1);
                 this.sessionIdNormalizer.addFinalIds(newBaseFinalId, lastFinalizedFinal, newCluster);
             }
@@ -467,7 +492,7 @@ export class IdCompressor {
                         (normalizedLastFinalizedLocal - overriddenLocal) -
                         1);
                 }
-                (_d = cluster.overrides) !== null && _d !== void 0 ? _d : (cluster.overrides = new Map());
+                (_h = cluster.overrides) !== null && _h !== void 0 ? _h : (cluster.overrides = new Map());
                 const inversionKey = IdCompressor.createInversionKey(override);
                 const existingIds = this.getExistingIdsForNewOverride(inversionKey, true);
                 let overrideForCluster;
@@ -533,6 +558,15 @@ export class IdCompressor {
                 }
             }
         }
+        if (isLocal) {
+            (_j = this.logger) === null || _j === void 0 ? void 0 : _j.sendTelemetryEvent({
+                eventName: 'IdCompressor:IdCompressorStatus',
+                eagerFinalIdCount,
+                localIdCount: remainingCount,
+                overridesCount: (_k = overrides === null || overrides === void 0 ? void 0 : overrides.length) !== null && _k !== void 0 ? _k : 0,
+                sessionId: this.localSessionId,
+            });
+        }
         session.lastFinalizedLocalId = newLastFinalizedLocal;
     }
     checkClusterForCollision(cluster) {
@@ -750,12 +784,9 @@ export class IdCompressor {
             // `localOverrides`s. Otherwise, it is a sequential allocation from the session UUID and can simply be negated and
             // added to that UUID to obtain the stable ID associated with it.
             const localOverride = (_a = this.localOverrides) === null || _a === void 0 ? void 0 : _a.get(id);
-            if (localOverride !== undefined) {
-                return localOverride;
-            }
-            else {
-                return stableIdFromNumericUuid(this.localSession.sessionUuid, idOffset - 1);
-            }
+            return localOverride !== undefined
+                ? localOverride
+                : stableIdFromNumericUuid(this.localSession.sessionUuid, idOffset - 1);
         }
     }
     /**
@@ -789,12 +820,9 @@ export class IdCompressor {
             const [key, compressionMapping] = closestMatch;
             if (!IdCompressor.isClusterInfo(compressionMapping)) {
                 if (key === inversionKey) {
-                    if (IdCompressor.isUnfinalizedOverride(compressionMapping)) {
-                        return compressionMapping;
-                    }
-                    else {
-                        return ((_a = compressionMapping.associatedLocalId) !== null && _a !== void 0 ? _a : compressionMapping.originalOverridingFinal);
-                    }
+                    return IdCompressor.isUnfinalizedOverride(compressionMapping)
+                        ? compressionMapping
+                        : (_a = compressionMapping.associatedLocalId) !== null && _a !== void 0 ? _a : compressionMapping.originalOverridingFinal;
                 }
             }
             else {