feat: select least loaded WPT location on new test run (DELO-4766)

Author: lukaszczerpak-cloudinary

package.json

@@ -9,6 +9,7 @@
   },
   "dependencies": {
     "async": "^3.2.6",
+    "async-mutex": "^0.5.0",
     "body-parser": "~1.20.3",
     "bytes": "^3.1.2",
     "cloudinary": "1.41.3",

routes/wpt.js

@@ -2,6 +2,7 @@
 const express = require('express');
 const validUrl = require('valid-url');
 const apiCaller = require('../wtp/apiCaller');
+const locationSelector = require("../wtp/locationSelector");
 const logger = require('../logger').logger;
 const {LOG_LEVEL_INFO, LOG_LEVEL_WARNING, LOG_LEVEL_ERROR, LOG_LEVEL_CRITICAL, LOG_LEVEL_DEBUG} = require('../logger');
 const path = require('path');
@@ -81,7 +82,19 @@ const wtp = (app) => {
   app.get('/version', (req, res) => {
     const packageJson = require('../package.json');
     res.json({version: packageJson.version});
+  });
+
+  app.get('/locations', async (req, res) => {
+    let locations = locationSelector.cachedAllLocations;
+    res.json({locations});
   })
+
+  app.get('/locations/current', async (req, res) => {
+    let location = locationSelector.location;
+    let lastUpdated = new Date(locationSelector.lastUpdated || 0).toISOString();
+    res.json({location, lastUpdated});
+  })
+
 };
 
 module.exports = wtp;

wtp/apiCaller.js

@@ -4,7 +4,6 @@
 
 "use strict";
 
-
 const path = require('path');
 const got = (...args) => import('got').then(({default: got}) => got(...args));
 const config = require('config');
@@ -16,7 +15,8 @@ const {truncateString} = require('../util/strings');
 const RESULTS_URL = 'https://www.webpagetest.org/jsonResult.php';
 const RUN_TEST_URL = 'http://www.webpagetest.org/runtest.php';
 const GET_TEST_STATUS = 'http://www.webpagetest.org/testStatus.php';
-
+const locationSelector = require('./locationSelector');
+const apiKeys = require('./apiKey');
 
 const getTestResults = async (testId, quality, cb) => {
   let options = {
@@ -58,11 +58,8 @@ const getTestResults = async (testId, quality, cb) => {
   }
 };
 
-
 const runWtpTest = async (url, mobile, cb) => {
   //logger.info('Running new test ' + url);
-  const apiKeys = config.get('wtp.apiKey').split(',');
-  const apiKey = apiKeys[Math.floor(Math.random() * apiKeys.length)];
   let options = {
     method: "POST",
     url: RUN_TEST_URL,
@@ -72,12 +69,12 @@ const runWtpTest = async (url, mobile, cb) => {
             width: config.get('wtp.viewportWidth'),
             height: config.get('wtp.viewportHeight'),
             custom: config.get('wtp.imageScript'),
-            location: 'Dulles:Chrome.Native', // Native means no speed shaping in browser, full speed ahead
-            mobile: (mobile) ? 1 : 0,
+            location: await locationSelector.getLocation() + ':Chrome.Native', // Native means no speed shaping in browser, full speed ahead
+      mobile: (mobile) ? 1 : 0,
             fvonly: 1, // first view only
             timeline: 1 // workaround for WPT sometimes hanging on getComputedStyle()
           },
-    headers: { 'User-Agent': 'WebSpeedTest', 'X-WPT-API-KEY': apiKey },
+    headers: { 'User-Agent': 'WebSpeedTest', 'X-WPT-API-KEY': apiKeys.get() },
     throwHttpErrors: false
   };
   let response;

wtp/apiKey.js

@@ -0,0 +1,13 @@
+"use strict";
+
+const config = require('config');
+
+function get() {
+  const apiKeys = config.get('wtp.apiKey').split(',');
+  const apiKey = apiKeys[Math.floor(Math.random() * apiKeys.length)];
+  return apiKey;
+}
+
+module.exports = {
+  get
+};

wtp/locationSelector.js

@@ -0,0 +1,105 @@
+const got = (...args) => import('got').then(({default: got}) => got(...args));
+const {Mutex} = require('async-mutex');
+const apiKeys = require('./apiKey');
+const path = require("path");
+const logger = require('../logger').logger;
+
+const GET_LOCATIONS = 'http://www.webpagetest.org/getLocations.php?f=json';
+
+class LocationSelector {
+    CACHE_TTL = 10;
+    DEFAULT_LOCATION = 'IAD_US_01';
+
+    constructor() {
+        if (!LocationSelector.instance) {
+            this.cachedAllLocations = [];
+            this.location = this.DEFAULT_LOCATION;
+            this.lastUpdated = null;
+            this.mutex = new Mutex();
+            LocationSelector.instance = this;
+        }
+        return LocationSelector.instance;
+    }
+
+    isExpired() {
+        const now = Date.now();
+        return (!this.lastUpdated || (now - this.lastUpdated) > this.CACHE_TTL * 1000);
+    }
+
+    async fetchLocations() {
+        let options = {
+            method: "GET",
+            url: GET_LOCATIONS,
+            headers: {'User-Agent': 'WebSpeedTest', 'X-WPT-API-KEY': apiKeys.get()},
+        };
+        let response;
+        let rollBarMsg = {};
+        try {
+            response = await got(options);
+            const {statusCode, body} = response;
+            let bodyJson = JSON.parse(body);
+            rollBarMsg = {thirdPartyErrorCode: response.statusCode, file: path.basename((__filename))};
+            if (statusCode !== 200) {
+                rollBarMsg.thirdPartyErrorBody = bodyJson;
+                logger.error('WPT returned bad status', rollBarMsg);
+                return;
+            }
+            return bodyJson.data;
+        } catch (error) {
+            logger.critical('Error fetching WTP locations', JSON.stringify(error, Object.getOwnPropertyNames(error)));
+        }
+    };
+
+    getLocationScore(location) {
+        let metrics = location.PendingTests;
+
+        // Idle + Testing ==> capacity
+        if (metrics.Idle + metrics.Testing == 0) {
+            return 1;   // no instances running, hopefully they will be spin up for our request?
+        }
+
+        return (metrics.HighPriority + metrics.Testing) / (metrics.Idle + metrics.Testing)
+    }
+
+    getBestLocationId(locations) {
+        let selected = locations.reduce((acc, cur) => acc && this.getLocationScore(acc) < this.getLocationScore(cur) ? acc : cur);
+        return selected.location;
+    }
+
+    async updateLocations() {
+        const newLocations = await this.fetchLocations();
+        if (!newLocations) {
+            return
+        }
+
+        const filtered = Object.keys(newLocations)
+            .filter(key => key.includes("_US_"))    // we only want US-based instances
+            .reduce((arr, key) => {
+                return [...arr, newLocations[key]];
+            }, []);
+
+        if (filtered.length === 0) {
+            return
+        }
+
+        this.location = this.getBestLocationId(filtered);
+        this.cachedAllLocations = filtered;
+        this.lastUpdated = Date.now();
+    };
+
+    async getLocation() {
+        if (this.isExpired()) {
+            await this.mutex.runExclusive(async () => {
+                if (this.isExpired()) {
+                    await this.updateLocations();
+                }
+            });
+        }
+
+        return this.location;
+    }
+}
+
+const instance = new LocationSelector();
+
+module.exports = instance;