@xenon-device-management/xenon 2.11.0 → 2.11.1

package/lib/test/unit/hub-node-session-metrics.spec.js

@@ -44,6 +44,7 @@ const appiumUmbrella_1 = require("../../src/sessions/appiumUmbrella");
 const config_1 = require("../../src/config");
 const container_registration_1 = require("../helpers/container-registration");
 const scratch_database_1 = require("../helpers/scratch-database");
+const selector_health_fixture_1 = require("../helpers/selector-health-fixture");
 const appium_umbrella_1 = require("../helpers/appium-umbrella");
 /**
  * A hub collects CPU and memory for a session on a node's phone from the
@@ -67,6 +68,19 @@ class NodeSideMetrics extends SessionMetricsService_1.SessionMetricsService {
         return { start: () => undefined, stop: () => __awaiter(this, void 0, void 0, function* () { return void (this.stopped += 1); }) };
     }
 }
+const hubContext = () => ({
+    pluginArgs: Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), { bindHostOrIp: '127.0.0.1' }),
+    port: 4799,
+    nodeId: 'hub-1',
+});
+const fastCollector = (source, hooks, after) => new NodeMetricsCollector_1.NodeMetricsCollector({
+    source,
+    hooks,
+    after,
+    support: typedi_1.Container.get(nodeMetrics_1.NodeMetricsSupport),
+    logger: quiet,
+    intervalMs: 50,
+});
 /** The hub's sampler service: this hub's own phones are none, it asks the node every 50 ms. */
 class HubSideMetrics extends SessionMetricsService_1.SessionMetricsService {
     constructor() {
@@ -74,11 +88,7 @@ class HubSideMetrics extends SessionMetricsService_1.SessionMetricsService {
         this.written = [];
     }
     context() {
-        return {
-            pluginArgs: Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), { bindHostOrIp: '127.0.0.1' }),
-            port: 4799,
-            nodeId: 'hub-1',
-        };
+        return hubContext();
     }
     writeSamples(_id, samples) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -86,16 +96,29 @@ class HubSideMetrics extends SessionMetricsService_1.SessionMetricsService {
         });
     }
     collectorFor(source, hooks, after) {
-        return new NodeMetricsCollector_1.NodeMetricsCollector({
-            source,
-            hooks,
-            after,
-            support: typedi_1.Container.get(nodeMetrics_1.NodeMetricsSupport),
-            logger: quiet,
-            intervalMs: 50,
-        });
+        return fastCollector(source, hooks, after);
+    }
+}
+/** The same, writing to the hub's database every 100 ms, as the page reads it. */
+class HubStoringMetrics extends SessionMetricsService_1.SessionMetricsService {
+    context() {
+        return hubContext();
+    }
+    flushIntervalMs() {
+        return 100;
+    }
+    collectorFor(source, hooks, after) {
+        return fastCollector(source, hooks, after);
     }
 }
+const untilAsync = (ok_1, ...args_1) => __awaiter(void 0, [ok_1, ...args_1], void 0, function* (ok, ms = 5000) {
+    const end = Date.now() + ms;
+    while (!(yield ok())) {
+        if (Date.now() > end)
+            throw new Error('timed out');
+        yield new Promise((r) => setTimeout(r, 50));
+    }
+});
 const until = (ok_1, ...args_1) => __awaiter(void 0, [ok_1, ...args_1], void 0, function* (ok, ms = 5000) {
     const end = Date.now() + ms;
     while (!ok()) {
@@ -310,6 +333,53 @@ describe('a hub collects a node session’s CPU and memory', function () {
         yield hub.stop(sessionId);
         (0, chai_1.expect)(hub.written).to.deep.equal([1000, 2000, 3000]);
     }));
+    it("shows a node session's figures on the hub's own metrics route while it runs", () => __awaiter(this, void 0, void 0, function* () {
+        yield boot();
+        const sessionId = yield nodeSession();
+        nodeMetrics.hooks[0].onSample(at(1000));
+        nodeMetrics.hooks[0].onSample(at(2000));
+        // The hub's row for the session, as onSessionStarted writes it.
+        yield scratch.db.session.create({
+            data: {
+                id: sessionId,
+                device_udid: 'phone-1',
+                device_platform: 'android',
+                device_version: '14',
+                desired_capabilities: '{}',
+                session_capabilities: '{}',
+                node_id: NODE_ID,
+                has_live_video: false,
+                status: 'running',
+            },
+        });
+        const hub = new HubStoringMetrics();
+        const device = {
+            udid: 'phone-1',
+            host: nodeOrigin,
+            nodeId: NODE_ID,
+            platform: 'android',
+            realDevice: true,
+        };
+        hub.start({ sessionId, device, capabilities: {}, source: hubSide(sessionId) });
+        // The route asks the server's own service whether the session is sampled.
+        typedi_1.Container.set(SessionMetricsService_1.SessionMetricsService, hub);
+        try {
+            const page = (0, selector_health_fixture_1.selectorHealthApp)(selector_health_fixture_1.ADMIN);
+            let body;
+            yield untilAsync(() => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                body = (yield (0, loopbackRequest_1.default)(page).get(`/session/${sessionId}/metrics`)).body;
+                return ((_a = body === null || body === void 0 ? void 0 : body.samples) === null || _a === void 0 ? void 0 : _a.length) === 2;
+            }));
+            (0, chai_1.expect)(body.recording).to.equal('sampling');
+            (0, chai_1.expect)(body.samples.map((x) => x.t)).to.deep.equal([1000, 2000]);
+            (0, chai_1.expect)(body.samples[1]).to.include({ deviceCpu: 12, app: 'com.android.settings' });
+        }
+        finally {
+            typedi_1.Container.set(SessionMetricsService_1.SessionMetricsService, nodeMetrics);
+            yield hub.stop(sessionId);
+        }
+    }));
     it("an older node's sessions say they aren't recorded", () => __awaiter(this, void 0, void 0, function* () {
         yield boot();
         const sessionId = yield nodeSession();

package/lib/test/unit/node-metrics-collector.spec.js

@@ -17,6 +17,8 @@ const chai_1 = require("chai");
 const sinon_1 = __importDefault(require("sinon"));
 const NodeMetricsCollector_1 = require("../../src/services/metrics/NodeMetricsCollector");
 const nodeMetrics_1 = require("../../src/services/metrics/nodeMetrics");
+const RemoteSession_1 = require("../../src/sessions/RemoteSession");
+const CloudSession_1 = require("../../src/sessions/CloudSession");
 const sample = (at) => ({
     at,
     deviceCpuPct: 5,
@@ -163,6 +165,16 @@ describe('NodeMetricsCollector: the hub collects a node session’s figures', ()
         (0, chai_1.expect)(warned).to.have.length(2);
         (0, chai_1.expect)(c.state()).to.equal('sampling');
     }));
+    it("doesn't wait on a last ask when the node already wasn't answering", () => __awaiter(void 0, void 0, void 0, function* () {
+        // A dark node's sessions are ended one after another by the heartbeat;
+        // each would wait up to 5 s more for an answer that won't come.
+        replies = [{ kind: 'unavailable', reason: 'ECONNREFUSED' }];
+        const c = make();
+        c.start();
+        yield clock.tickAsync(10000);
+        yield c.stop();
+        (0, chai_1.expect)(asked).to.have.length(1);
+    }));
     it('finishes stopping when the node is unreachable', () => __awaiter(void 0, void 0, void 0, function* () {
         replies = [{ kind: 'unavailable', reason: 'timeout' }];
         const c = make();
@@ -188,6 +200,27 @@ describe('NodeMetricsCollector: the hub collects a node session’s figures', ()
 });
 describe("readNodeMetricsReply: what a node's answer means", () => {
     const h = { [nodeMetrics_1.NODE_METRICS_HEADER]: '1' };
+    it('keeps only well-formed samples: one bad sample would block every later write', () => {
+        const bad = [
+            null,
+            'x',
+            Object.assign(Object.assign({}, sample(5)), { at: '6' }),
+            Object.assign(Object.assign({}, sample(7)), { at: Number.NaN }),
+            Object.assign(Object.assign({}, sample(8)), { deviceCpuPct: '12' }),
+            Object.assign(Object.assign({}, sample(9)), { appId: 3 }),
+        ];
+        const reply = (0, nodeMetrics_1.readNodeMetricsReply)(200, h, {
+            value: {
+                platform: 'android',
+                state: 'sampling',
+                samples: [sample(1), ...bad, Object.assign(Object.assign({}, sample(2)), { extra: 1 })],
+            },
+        });
+        (0, chai_1.expect)(reply).to.deep.equal({
+            kind: 'answer',
+            answer: { platform: 'android', state: 'sampling', samples: [sample(1), sample(2)] },
+        });
+    });
     it('reads each answer', () => {
         (0, chai_1.expect)((0, nodeMetrics_1.readNodeMetricsReply)(404, {}, undefined)).to.deep.equal({
             kind: 'unsupported',
@@ -224,3 +257,23 @@ describe("readNodeMetricsReply: what a node's answer means", () => {
         });
     });
 });
+describe('nodeMetricsSourceOf: only a session a node runs is collected from', () => {
+    const options = (cloud) => ({
+        sessionId: 's1',
+        device: { udid: 'p1', host: 'http://node:4723', platform: 'android', cloud },
+        sessionResponse: {},
+        xenonOption: {},
+        baseUrl: 'http://node:4723/wd/hub',
+    });
+    it("takes a node's session, never a cloud provider's or this server's own", () => {
+        const remote = new RemoteSession_1.RemoteSession(options());
+        (0, chai_1.expect)((0, nodeMetrics_1.nodeMetricsSourceOf)(remote)).to.equal(remote);
+        // Both inherit nodeMetrics from RemoteSession; neither runs on a node.
+        (0, chai_1.expect)((0, nodeMetrics_1.nodeMetricsSourceOf)(new CloudSession_1.CloudSession(options('browserstack')))).to.equal(undefined);
+        const local = Object.assign(Object.create(RemoteSession_1.RemoteSession.prototype), {
+            getType: () => 'local',
+        });
+        (0, chai_1.expect)((0, nodeMetrics_1.nodeMetricsSourceOf)(local)).to.equal(undefined);
+        (0, chai_1.expect)((0, nodeMetrics_1.nodeMetricsSourceOf)({ nodeOrigin: () => 'x', nodeMetrics: () => __awaiter(void 0, void 0, void 0, function* () { return null; }) })).to.equal(undefined);
+    });
+});

package/lib/test/unit/node-session-metrics-route.spec.js

@@ -76,7 +76,8 @@ describe("a node's session metrics route", () => {
     it('reads anything but a time as no `after`', () => {
         (0, chai_1.expect)((0, nodeSessionMetrics_1.parseAfter)('1500')).to.equal(1500);
         (0, chai_1.expect)((0, nodeSessionMetrics_1.parseAfter)('1500.5')).to.equal(1500.5);
-        for (const bad of [undefined, '', 'abc', '-5', '1e3', ['1']]) {
+        // A 400-digit number is Infinity: it would drop every sample the node holds.
+        for (const bad of [undefined, '', 'abc', '-5', '1e3', ['1'], '9'.repeat(400)]) {
             (0, chai_1.expect)((0, nodeSessionMetrics_1.parseAfter)(bad), String(bad)).to.equal(null);
         }
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xenon-device-management/xenon",
-  "version": "2.11.0",
+  "version": "2.11.1",
   "description": "Xenon - Intelligent Mobile Infrastructure. A self-healing device orchestration platform for Appium.",
   "main": "./lib/src/index.js",
   "exports": {