Merge pull request #2222 from matrix-org/bwindels/phasedrollout

Phased rollout of lazy loading

src/MatrixClientPeg.js

@@ -26,6 +26,7 @@ import EventTimelineSet from 'matrix-js-sdk/lib/models/event-timeline-set';
 import createMatrixClient from './utils/createMatrixClient';
 import SettingsStore from './settings/SettingsStore';
 import MatrixActionCreators from './actions/MatrixActionCreators';
+import {phasedRollOutExpiredForUser} from "./PhasedRollOut";
 
 interface MatrixClientCreds {
     homeserverUrl: string,
@@ -124,8 +125,12 @@ class MatrixClientPeg {
         // the react sdk doesn't work without this, so don't allow
         opts.pendingEventOrdering = "detached";
 
-        if (SettingsStore.isFeatureEnabled('feature_lazyloading')) {
-            opts.lazyLoadMembers = true;
+        const LAZY_LOADING_FEATURE = "feature_lazyloading";
+        if (SettingsStore.isFeatureEnabled(LAZY_LOADING_FEATURE)) {
+            const userId = this.matrixClient.credentials.userId;
+            if (phasedRollOutExpiredForUser(userId, LAZY_LOADING_FEATURE, Date.now())) {
+                opts.lazyLoadMembers = true;
+            }
         }
 
         // Connect the matrix client to the dispatcher

src/PhasedRollOut.js

@@ -0,0 +1,65 @@
+/*
+Copyright 2018 New Vector Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import SdkConfig from './SdkConfig';
+
+function hashCode(str) {
+    let hash = 0;
+    let i;
+    let chr;
+    if (str.length === 0) {
+        return hash;
+    }
+    for (i = 0; i < str.length; i++) {
+        chr = str.charCodeAt(i);
+        hash = ((hash << 5) - hash) + chr;
+        hash |= 0;
+    }
+    return Math.abs(hash);
+}
+
+export function phasedRollOutExpiredForUser(username, feature, now, rollOutConfig = SdkConfig.get().phasedRollOut) {
+    if (!rollOutConfig) {
+        console.log(`no phased rollout configuration, so enabling ${feature}`);
+        return true;
+    }
+    const featureConfig = rollOutConfig[feature];
+    if (!featureConfig) {
+        console.log(`${feature} doesn't have phased rollout configured, so enabling`);
+        return true;
+    }
+    if (!Number.isFinite(featureConfig.offset) || !Number.isFinite(featureConfig.period)) {
+        console.error(`phased rollout of ${feature} is misconfigured, ` +
+            `offset and/or period are not numbers, so disabling`, featureConfig);
+        return false;
+    }
+
+    const hash = hashCode(username);
+    //ms -> min, enable users at minute granularity
+    const bucketRatio = 1000 * 60;
+    const bucketCount = featureConfig.period / bucketRatio;
+    const userBucket = hash % bucketCount;
+    const userMs = userBucket * bucketRatio;
+    const enableAt = featureConfig.offset + userMs;
+    const result = now >= enableAt;
+    const bucketStr = `(bucket ${userBucket}/${bucketCount})`;
+    if (result) {
+        console.log(`${feature} enabled for ${username} ${bucketStr}`);
+    } else {
+        console.log(`${feature} will be enabled for ${username} in ${Math.ceil((enableAt - now)/1000)}s ${bucketStr}`);
+    }
+    return result;
+}

test/PhasedRollOut-test.js

@@ -0,0 +1,72 @@
+/*
+Copyright 2018 New Vector Ltd
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import expect from 'expect';
+import {phasedRollOutExpiredForUser} from '../src/PhasedRollOut';
+
+const OFFSET = 6000000;
+// phasedRollOutExpiredForUser enables users in bucks of 1 minute
+const MS_IN_MINUTE = 60 * 1000;
+
+describe('PhasedRollOut', function() {
+    it('should return true if phased rollout is not configured', function() {
+        expect(phasedRollOutExpiredForUser("@user:hs", "feature_test", 0, null)).toBeTruthy();
+    });
+
+    it('should return true if phased rollout feature is not configured', function() {
+        expect(phasedRollOutExpiredForUser("@user:hs", "feature_test", 0, {
+            "feature_other": {offset: 0, period: 0},
+        })).toBeTruthy();
+    });
+
+    it('should return false if phased rollout for feature is misconfigured', function() {
+        expect(phasedRollOutExpiredForUser("@user:hs", "feature_test", 0, {
+            "feature_test": {},
+        })).toBeFalsy();
+    });
+
+    it("should return false if phased rollout hasn't started yet", function() {
+        expect(phasedRollOutExpiredForUser("@user:hs", "feature_test", 5000000, {
+            "feature_test": {offset: OFFSET, period: MS_IN_MINUTE},
+        })).toBeFalsy();
+    });
+
+    it("should start to return true in bucket 2/10 for '@user:hs'", function() {
+        expect(phasedRollOutExpiredForUser("@user:hs", "feature_test",
+            OFFSET + (MS_IN_MINUTE * 2) - 1, {
+            "feature_test": {offset: OFFSET, period: MS_IN_MINUTE * 10},
+        })).toBeFalsy();
+        expect(phasedRollOutExpiredForUser("@user:hs", "feature_test",
+            OFFSET + (MS_IN_MINUTE * 2), {
+            "feature_test": {offset: OFFSET, period: MS_IN_MINUTE * 10},
+        })).toBeTruthy();
+    });
+
+    it("should start to return true in bucket 4/10 for 'alice@other-hs'", function() {
+        expect(phasedRollOutExpiredForUser("alice@other-hs", "feature_test",
+            OFFSET + (MS_IN_MINUTE * 4) - 1, {
+            "feature_test": {offset: OFFSET, period: MS_IN_MINUTE * 10},
+        })).toBeFalsy();
+        expect(phasedRollOutExpiredForUser("alice@other-hs", "feature_test",
+            OFFSET + (MS_IN_MINUTE * 4), {
+            "feature_test": {offset: OFFSET, period: MS_IN_MINUTE * 10},
+        })).toBeTruthy();
+    });
+
+    it("should return true after complete rollout period'", function() {
+        expect(phasedRollOutExpiredForUser("user:hs", "feature_test",
+            OFFSET + (MS_IN_MINUTE * 20), {
+            "feature_test": {offset: OFFSET, period: MS_IN_MINUTE * 10},
+        })).toBeTruthy();
+    });
+});