@xenon-device-management/xenon 2.10.1 → 2.11.0

package/lib/src/gateway/nodeSessionStatus.js

@@ -10,6 +10,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NodeSessionProbeSupport = exports.UNSUPPORTED_RECHECK_MS = exports.NODE_SESSION_STATUS_HEADER = exports.NODE_SESSION_STATUS_PATH = exports.NODE_SESSION_STATUS_ROUTE = void 0;
+exports.answerForHub = answerForHub;
 exports.nodeSessionStatusHandler = nodeSessionStatusHandler;
 exports.registerNodeSessionStatus = registerNodeSessionStatus;
 const typedi_1 = require("typedi");
@@ -54,34 +55,42 @@ exports.NODE_SESSION_STATUS_PATH = '/xenon/api/node/sessions';
 exports.NODE_SESSION_STATUS_HEADER = 'x-xenon-node-sessions';
 /** How long a hub keeps using the old probe for a node without the route before asking again. */
 exports.UNSUPPORTED_RECHECK_MS = 10 * 60000;
+/**
+ * Runs `answer` when the caller may know this session's state on the node:
+ * always with per-command auth off, else only with the hub's session token
+ * for it. Otherwise the unknown-session answer, or 503 when the token can't
+ * be checked. `what` names the route in the log.
+ */
+function answerForHub(deps, req, res, sessionId, what, answer) {
+    if (!deps.enforced())
+        return answer();
+    const presented = req.headers[hubSessionToken_1.HUB_TOKEN_HEADER];
+    const token = typeof presented === 'string' ? presented : undefined;
+    if (token === undefined) {
+        res.status(commandAuth_1.UNKNOWN_SESSION_STATUS).json(commandAuth_1.UNKNOWN_SESSION_BODY);
+        return;
+    }
+    deps.hubTokens
+        .verify(token, sessionId)
+        .then((valid) => {
+        if (valid)
+            return answer();
+        deps.logger.warn(`${what} for ${sessionId} refused: the hub token is not valid for it`);
+        res.status(commandAuth_1.UNKNOWN_SESSION_STATUS).json(commandAuth_1.UNKNOWN_SESSION_BODY);
+    })
+        .catch((error) => {
+        deps.logger.error(`${what} for ${sessionId} unavailable: hub token check failed: ${(0, commandAuth_1.summarize)(error)}`);
+        if (!res.headersSent) {
+            res.status(commandAuth_1.COMMAND_AUTH_UNAVAILABLE_STATUS).json(commandAuth_1.COMMAND_AUTH_UNAVAILABLE_BODY);
+        }
+    });
+}
 function nodeSessionStatusHandler(deps) {
     return (req, res) => {
         var _a, _b;
         res.setHeader(exports.NODE_SESSION_STATUS_HEADER, '1');
         const sessionId = String((_b = (_a = req.params) === null || _a === void 0 ? void 0 : _a.sessionId) !== null && _b !== void 0 ? _b : '');
-        const answer = () => res.status(200).json({ value: { sessionId, exists: deps.hasSession(sessionId) } });
-        if (!deps.enforced())
-            return answer();
-        const presented = req.headers[hubSessionToken_1.HUB_TOKEN_HEADER];
-        const token = typeof presented === 'string' ? presented : undefined;
-        if (token === undefined) {
-            res.status(commandAuth_1.UNKNOWN_SESSION_STATUS).json(commandAuth_1.UNKNOWN_SESSION_BODY);
-            return;
-        }
-        deps.hubTokens
-            .verify(token, sessionId)
-            .then((valid) => {
-            if (valid)
-                return answer();
-            deps.logger.warn(`Session status for ${sessionId} refused: the hub token is not valid for it`);
-            res.status(commandAuth_1.UNKNOWN_SESSION_STATUS).json(commandAuth_1.UNKNOWN_SESSION_BODY);
-        })
-            .catch((error) => {
-            deps.logger.error(`Session status for ${sessionId} unavailable: hub token check failed: ${(0, commandAuth_1.summarize)(error)}`);
-            if (!res.headersSent) {
-                res.status(commandAuth_1.COMMAND_AUTH_UNAVAILABLE_STATUS).json(commandAuth_1.COMMAND_AUTH_UNAVAILABLE_BODY);
-            }
-        });
+        answerForHub(deps, req, res, sessionId, 'Session status', () => res.status(200).json({ value: { sessionId, exists: deps.hasSession(sessionId) } }));
     };
 }
 /**

package/lib/src/plugin.js

@@ -66,6 +66,7 @@ const IPluginArgs_1 = require("./interfaces/IPluginArgs");
 const NodeDevices_1 = __importDefault(require("./device-managers/NodeDevices"));
 const appiumUmbrella_1 = require("./sessions/appiumUmbrella");
 const LiveSessionOwners_1 = require("./services/device-access/LiveSessionOwners");
+const SessionMetricsService_1 = require("./services/metrics/SessionMetricsService");
 const config_1 = require("./config");
 const SessionManager_1 = require("./sessions/SessionManager");
 const event_manager_1 = require("./dashboard/event-manager");
@@ -98,6 +99,8 @@ class XenonPlugin extends base_plugin_1.default {
             var _a;
             const sessionId = driver.sessionId;
             typedi_1.Container.get(LiveSessionOwners_1.LiveSessionOwners).forget(sessionId);
+            if (sessionId)
+                yield typedi_1.Container.get(SessionMetricsService_1.SessionMetricsService).stop(sessionId);
             const deviceFilter = {
                 session_id: sessionId ? sessionId : undefined,
                 udid: driver.caps && driver.caps.udid ? driver.caps.udid : undefined,

package/lib/src/services/SessionLifecycleService.js

@@ -80,6 +80,7 @@ const callerTeamIds_1 = require("./device-access/callerTeamIds");
 const queueVisibility_1 = require("./device-access/queueVisibility");
 const appVisibility_1 = require("./device-access/appVisibility");
 const LiveSessionOwners_1 = require("./device-access/LiveSessionOwners");
+const SessionMetricsService_1 = require("./metrics/SessionMetricsService");
 const appCapability_1 = require("./session/appCapability");
 const CircuitBreaker_1 = require("../data-service/CircuitBreaker");
 const nodeWebDriverUrl_1 = require("../gateway/nodeWebDriverUrl");
@@ -816,6 +817,16 @@ let SessionLifecycleService = class SessionLifecycleService {
             if (sessionInstance instanceof LocalSession_1.LocalSession) {
                 typedi_1.Container.get(LiveSessionOwners_1.LiveSessionOwners).record(sessionId, userId);
             }
+            // A node samples its own phones for its hub, whatever its dashboard
+            // setting (the hub collects the figures). A hub and a standalone server
+            // start sampling in EventManager.onSessionStarted, once the row exists.
+            if (!this.isHub(context.pluginArgs) && sessionInstance instanceof LocalSession_1.LocalSession) {
+                typedi_1.Container.get(SessionMetricsService_1.SessionMetricsService).start({
+                    sessionId,
+                    device: freshDevice,
+                    capabilities: sessionResponse,
+                });
+            }
             yield this.applyPostSessionLogic(sessionInstance, xenonCapabilities, freshDevice);
         });
     }
@@ -1104,6 +1115,10 @@ let SessionLifecycleService = class SessionLifecycleService {
             finally {
                 if (sessionId) {
                     typedi_1.Container.get(LiveSessionOwners_1.LiveSessionOwners).forget(sessionId);
+                    // Before the lock's "still in memory?" check, which a dashboard-off
+                    // node fails. On a node this ends the figures it holds for its hub;
+                    // on a hub it collects a node session's last ones. Idempotent.
+                    yield typedi_1.Container.get(SessionMetricsService_1.SessionMetricsService).stop(sessionId);
                     yield sessionCleanupLock.acquire(sessionId, () => __awaiter(this, void 0, void 0, function* () {
                         const session = SessionManager_1.SESSION_MANAGER.getSession(sessionId);
                         if (!session) {
@@ -1238,6 +1253,7 @@ let SessionLifecycleService = class SessionLifecycleService {
                 }
                 SessionManager_1.SESSION_MANAGER.removeSession(sessionId);
                 typedi_1.Container.get(LiveSessionOwners_1.LiveSessionOwners).forget(sessionId);
+                yield typedi_1.Container.get(SessionMetricsService_1.SessionMetricsService).stop(sessionId);
             }));
         });
     }

package/lib/src/services/metrics/NodeMetricsCollector.js

@@ -0,0 +1,114 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeMetricsCollector = exports.COLLECT_INTERVAL_MS = void 0;
+/** How often the hub asks a node for a session's new figures. */
+exports.COLLECT_INTERVAL_MS = 10000;
+/**
+ * On a hub: a session on a node's phone, sampled by asking the node
+ * (GET /node/sessions/:id/metrics) every COLLECT_INTERVAL_MS instead of
+ * reading the phone. Its samples go through the same hooks as a phone
+ * sampler's, so SessionMetricsService buffers and writes them as its own.
+ * Asks never overlap. An unreachable node is asked again; whether the
+ * session is alive is the heartbeat's call. When the session ends it asks
+ * once more, for the last seconds.
+ */
+class NodeMetricsCollector {
+    constructor(o) {
+        var _a;
+        this.o = o;
+        this.current = 'sampling';
+        this.done = false;
+        this.asking = null;
+        this.outage = false;
+        this.after = (_a = o.after) !== null && _a !== void 0 ? _a : null;
+    }
+    state() {
+        return this.current;
+    }
+    start() {
+        var _a, _b, _c;
+        const origin = this.o.source.nodeOrigin();
+        if (!origin || !this.o.support.shouldAsk(origin)) {
+            this.finish('off');
+            return;
+        }
+        this.timer = setInterval(() => void this.tick(), (_a = this.o.intervalMs) !== null && _a !== void 0 ? _a : exports.COLLECT_INTERVAL_MS);
+        (_c = (_b = this.timer).unref) === null || _c === void 0 ? void 0 : _c.call(_b);
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.timer)
+                clearInterval(this.timer);
+            if (this.asking)
+                yield this.asking;
+            if (!this.done)
+                yield this.ask();
+            this.done = true;
+        });
+    }
+    tick() {
+        if (this.done || this.asking)
+            return undefined;
+        this.asking = this.ask().finally(() => {
+            this.asking = null;
+        });
+        return this.asking;
+    }
+    ask() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const reply = yield this.o.source.nodeMetrics(this.after);
+            switch (reply.kind) {
+                case 'answer': {
+                    if (this.outage) {
+                        this.outage = false;
+                        this.o.logger.info(`${this.o.source.nodeOrigin()} answers again`);
+                    }
+                    for (const s of reply.answer.samples) {
+                        if (this.after !== null && s.at <= this.after)
+                            continue;
+                        this.o.hooks.onSample(s);
+                        this.after = s.at;
+                    }
+                    const state = reply.answer.state;
+                    if (state === 'sampling')
+                        this.current = 'sampling';
+                    else
+                        this.finish(state === 'off' ? 'off' : 'stopped');
+                    return;
+                }
+                case 'unsupported':
+                    this.o.support.unsupported((_a = this.o.source.nodeOrigin()) !== null && _a !== void 0 ? _a : '', reply.status);
+                    this.finish('off');
+                    return;
+                case 'refused':
+                    this.finish('off');
+                    return;
+                case 'unavailable':
+                    if (!this.outage) {
+                        this.outage = true;
+                        this.o.logger.warn(`Can't collect CPU and memory from ${this.o.source.nodeOrigin()}: ${reply.reason}. Asking again.`);
+                    }
+                    return;
+            }
+        });
+    }
+    finish(state) {
+        // Figures already collected stay on the page: "stopped", never "off",
+        // which the panel shows as "isn't recorded" in their place.
+        this.current = state === 'off' && this.after !== null ? 'stopped' : state;
+        this.done = true;
+        if (this.timer)
+            clearInterval(this.timer);
+    }
+}
+exports.NodeMetricsCollector = NodeMetricsCollector;

package/lib/src/services/metrics/NodeMetricsStore.js

@@ -0,0 +1,76 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeMetricsStore = void 0;
+const typedi_1 = require("typedi");
+const nodeMetrics_1 = require("./nodeMetrics");
+const types_1 = require("./types");
+/**
+ * On a node: each sampled session's CPU and memory, held in memory until the
+ * hub collects them. A node has no Session row for a session its hub created,
+ * so it can't write them to SessionMetric. The newest MAX_BUFFERED_SAMPLES per
+ * session; what the hub has collected is dropped; an ended session is kept
+ * KEEP_AFTER_END_MS, then forgotten, whether or not a hub asked.
+ */
+let NodeMetricsStore = class NodeMetricsStore {
+    constructor() {
+        this.now = () => Date.now();
+        this.entries = new Map();
+    }
+    begin(sessionId, platform) {
+        this.prune();
+        this.entries.set(sessionId, {
+            platform: platform.toLowerCase(),
+            state: 'sampling',
+            samples: [],
+            endedAt: null,
+        });
+    }
+    add(sessionId, sample) {
+        const entry = this.entries.get(sessionId);
+        if (!entry)
+            return;
+        entry.samples.push(sample);
+        const over = entry.samples.length - types_1.MAX_BUFFERED_SAMPLES;
+        if (over > 0)
+            entry.samples.splice(0, over);
+    }
+    gaveUp(sessionId) {
+        const entry = this.entries.get(sessionId);
+        if (entry && entry.state === 'sampling')
+            entry.state = 'stopped';
+    }
+    end(sessionId) {
+        const entry = this.entries.get(sessionId);
+        if (!entry)
+            return;
+        entry.state = 'ended';
+        entry.endedAt = this.now();
+    }
+    /** The samples newer than `after` (all, without it). Those at or before it the hub has, so they go. */
+    read(sessionId, after) {
+        this.prune();
+        const entry = this.entries.get(sessionId);
+        if (!entry)
+            return { platform: '', state: 'off', samples: [] };
+        if (after !== null)
+            entry.samples = entry.samples.filter((s) => s.at > after);
+        return { platform: entry.platform, state: entry.state, samples: entry.samples.slice() };
+    }
+    prune() {
+        const cutoff = this.now() - nodeMetrics_1.KEEP_AFTER_END_MS;
+        for (const [id, entry] of this.entries) {
+            if (entry.endedAt !== null && entry.endedAt <= cutoff)
+                this.entries.delete(id);
+        }
+    }
+};
+exports.NodeMetricsStore = NodeMetricsStore;
+exports.NodeMetricsStore = NodeMetricsStore = __decorate([
+    (0, typedi_1.Service)()
+], NodeMetricsStore);

package/lib/src/services/metrics/SessionMetricsService.js

@@ -34,6 +34,9 @@ const ProcessRegistry_1 = require("../ProcessRegistry");
 const androidMetrics_1 = require("./androidMetrics");
 const AndroidMetricsSampler_1 = require("./AndroidMetricsSampler");
 const IOSMetricsSampler_1 = require("./IOSMetricsSampler");
+const NodeMetricsStore_1 = require("./NodeMetricsStore");
+const NodeMetricsCollector_1 = require("./NodeMetricsCollector");
+const nodeMetrics_1 = require("./nodeMetrics");
 const types_1 = require("./types");
 const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
 /** One adb call of a sample; one that hangs this long is a failed sample. */
@@ -42,15 +45,18 @@ const ADB_TIMEOUT_MS = 5000;
  * CPU and memory for the session page's Performance panel. A sampler per
  * session on this server's own phones, from EventManager's start (once the
  * session's row exists) to its stop; samples are written every
- * FLUSH_INTERVAL_MS. Sampling never fails a session.
+ * FLUSH_INTERVAL_MS. On a hub, a session on a node's phone gets a
+ * NodeMetricsCollector instead, which asks the node. On a node the samples
+ * are held for the hub (NodeMetricsStore), not written. Sampling never fails
+ * a session.
  */
 let SessionMetricsService = class SessionMetricsService {
     constructor() {
         this.log = logger_1.default.scope('SessionMetrics');
         this.running = new Map();
     }
-    /** Whether a session on this phone is sampled. */
-    appliesTo(device) {
+    /** Whether a session on this phone is sampled: this server's phone, or a node's through its session. */
+    appliesTo(device, source) {
         var _a, _b;
         if (!device)
             return false;
@@ -62,47 +68,77 @@ let SessionMetricsService = class SessionMetricsService {
         if (platform !== 'android' && !(platform === 'ios' && device.realDevice === true)) {
             return false;
         }
+        if (this.ownPhone(device))
+            return true;
+        // A node's phone, on a hub: collected from the node. Never a cloud provider's.
+        return !!source && !device.cloud && !this.holdsForHub();
+    }
+    ownPhone(device) {
+        const ctx = this.context();
         return (0, localDeviceHosts_1.isOwnDevice)((0, localDeviceHosts_1.localDeviceHosts)(ctx.pluginArgs, ctx.port), ctx.nodeId, device);
     }
-    start({ sessionId, device, capabilities }) {
-        var _a, _b;
-        if (this.running.has(sessionId) || !this.appliesTo(device))
+    start({ sessionId, device, capabilities, source, after }) {
+        var _a, _b, _c;
+        if (this.running.has(sessionId) || !this.appliesTo(device, source))
             return;
+        // A node has no Session row for the hub's sessions, so it holds the
+        // figures for its hub to collect (GET /node/sessions/:id/metrics).
+        const held = this.holdsForHub();
+        const store = held ? this.nodeStore() : null;
+        // The entry's own buffer, not a lookup by session: `stop` removes the
+        // entry first, and the hub's collector gives its last samples while it
+        // stops (its last ask of the node).
+        const buffer = [];
         const hooks = {
-            onSample: (s) => { var _a; return (_a = this.running.get(sessionId)) === null || _a === void 0 ? void 0 : _a.buffer.push(s); },
+            onSample: (s) => {
+                if (store)
+                    store.add(sessionId, s);
+                else
+                    buffer.push(s);
+            },
             onGiveUp: (reason) => {
                 const entry = this.running.get(sessionId);
                 if (entry)
                     entry.gaveUp = true;
+                store === null || store === void 0 ? void 0 : store.gaveUp(sessionId);
                 this.log.warn(`[${sessionId}] Stopped sampling ${device.udid}: ${reason}`);
             },
         };
         let sampler;
         try {
-            sampler = this.samplerFor(sessionId, device, capabilities, hooks);
+            sampler =
+                source && !this.ownPhone(device)
+                    ? this.collectorFor(source, hooks, after !== null && after !== void 0 ? after : null)
+                    : this.samplerFor(sessionId, device, capabilities, hooks);
         }
         catch (err) {
             this.log.warn(`[${sessionId}] Can't sample ${device.udid}: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
             return;
         }
-        const flushTimer = setInterval(() => void this.flush(sessionId), types_1.FLUSH_INTERVAL_MS);
-        (_b = flushTimer.unref) === null || _b === void 0 ? void 0 : _b.call(flushTimer);
+        store === null || store === void 0 ? void 0 : store.begin(sessionId, String((_b = device.platform) !== null && _b !== void 0 ? _b : ''));
+        let flushTimer;
+        if (!held) {
+            flushTimer = setInterval(() => void this.flush(sessionId), types_1.FLUSH_INTERVAL_MS);
+            (_c = flushTimer.unref) === null || _c === void 0 ? void 0 : _c.call(flushTimer);
+        }
         this.running.set(sessionId, {
             sampler,
-            buffer: [],
+            buffer,
             flushTimer,
             writing: Promise.resolve(),
             gaveUp: false,
+            held,
         });
         sampler.start();
         this.log.info(`[${sessionId}] Sampling CPU and memory on ${device.udid}`);
     }
     /** Whether this server is sampling a running session, stopped after giving up, or never did. */
     recordingState(sessionId) {
+        var _a, _b, _c;
         const entry = this.running.get(sessionId);
         if (!entry)
             return 'off';
-        return entry.gaveUp ? 'stopped' : 'sampling';
+        return (_c = (_b = (_a = entry.sampler).state) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : (entry.gaveUp ? 'stopped' : 'sampling');
     }
     /** Stops the session's sampler and writes what it buffered. Idempotent. */
     stop(sessionId) {
@@ -111,9 +147,13 @@ let SessionMetricsService = class SessionMetricsService {
             if (!entry)
                 return;
             this.running.delete(sessionId);
-            clearInterval(entry.flushTimer);
+            if (entry.flushTimer)
+                clearInterval(entry.flushTimer);
             yield entry.sampler.stop().catch(() => undefined);
-            yield this.write(sessionId, entry);
+            if (entry.held)
+                this.nodeStore().end(sessionId);
+            else
+                yield this.write(sessionId, entry);
         });
     }
     flush(sessionId) {
@@ -149,6 +189,23 @@ let SessionMetricsService = class SessionMetricsService {
     context() {
         return typedi_1.Container.get(PluginContext_1.PluginContext);
     }
+    /** A node (a server with `hub`) holds the figures for its hub instead of writing them. */
+    holdsForHub() {
+        var _a;
+        return ((_a = this.context().pluginArgs) === null || _a === void 0 ? void 0 : _a.hub) !== undefined;
+    }
+    nodeStore() {
+        return typedi_1.Container.get(NodeMetricsStore_1.NodeMetricsStore);
+    }
+    collectorFor(source, hooks, after) {
+        return new NodeMetricsCollector_1.NodeMetricsCollector({
+            source,
+            hooks,
+            after,
+            support: typedi_1.Container.get(nodeMetrics_1.NodeMetricsSupport),
+            logger: this.log,
+        });
+    }
     writeSamples(sessionId, samples) {
         return __awaiter(this, void 0, void 0, function* () {
             yield prisma_1.prisma.sessionMetric.createMany({

package/lib/src/services/metrics/nodeMetrics.js

@@ -0,0 +1,92 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeMetricsSupport = exports.NODE_METRICS_RECHECK_MS = exports.KEEP_AFTER_END_MS = exports.NODE_METRICS_HEADER = exports.NODE_METRICS_ROUTE = void 0;
+exports.readNodeMetricsReply = readNodeMetricsReply;
+exports.nodeMetricsSourceOf = nodeMetricsSourceOf;
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../../logger"));
+/** Where a node serves a session's figures, under `/xenon/api`. */
+exports.NODE_METRICS_ROUTE = '/node/sessions/:sessionId/metrics';
+/** On every answer of that route, so a hub can tell a node that has it. */
+exports.NODE_METRICS_HEADER = 'x-xenon-node-metrics';
+/** How long a node keeps an ended session's figures for its hub's last collection. */
+exports.KEEP_AFTER_END_MS = 10 * 60000;
+const STATES = ['sampling', 'stopped', 'ended', 'off'];
+function readNodeMetricsReply(status, headers, data) {
+    var _a;
+    if (!(headers === null || headers === void 0 ? void 0 : headers[exports.NODE_METRICS_HEADER])) {
+        // An older node answers its login's 401, an unknown route's 404, or a
+        // catch-all's 2xx. Anything else without the header (a proxy's 502 in
+        // front of a node) is an outage: ask again, never give the node up.
+        if (status === 401 || status === 404 || (status >= 200 && status < 300)) {
+            return { kind: 'unsupported', status };
+        }
+        return { kind: 'unavailable', reason: `answered ${status}` };
+    }
+    if (status === 404)
+        return { kind: 'refused' };
+    const value = data === null || data === void 0 ? void 0 : data.value;
+    if (status === 200 && value && STATES.includes(value.state) && Array.isArray(value.samples)) {
+        return {
+            kind: 'answer',
+            answer: {
+                platform: String((_a = value.platform) !== null && _a !== void 0 ? _a : ''),
+                state: value.state,
+                samples: value.samples,
+            },
+        };
+    }
+    return { kind: 'unavailable', reason: `answered ${status}` };
+}
+/** The session as a NodeMetricsSource, when it is one. */
+function nodeMetricsSourceOf(session) {
+    const s = session;
+    return s && typeof s.nodeMetrics === 'function' && typeof s.nodeOrigin === 'function'
+        ? s
+        : undefined;
+}
+/** How long the hub leaves a node without the route alone before asking it again. */
+exports.NODE_METRICS_RECHECK_MS = 10 * 60000;
+/**
+ * Hub side: which nodes lack the route (an older Xenon). Their sessions show
+ * no figures; the hub says so once per node, and asks again after
+ * NODE_METRICS_RECHECK_MS, so a node upgraded in place is picked up.
+ */
+let NodeMetricsSupport = class NodeMetricsSupport {
+    constructor() {
+        this.logger = logger_1.default.scope('NodeMetrics');
+        this.now = () => Date.now();
+        this.unsupportedUntil = new Map();
+        this.warned = new Set();
+    }
+    shouldAsk(origin) {
+        const until = this.unsupportedUntil.get(origin);
+        if (until === undefined)
+            return true;
+        if (until > this.now())
+            return false;
+        this.unsupportedUntil.delete(origin);
+        return true;
+    }
+    unsupported(origin, status) {
+        this.unsupportedUntil.set(origin, this.now() + exports.NODE_METRICS_RECHECK_MS);
+        if (this.warned.has(origin))
+            return;
+        this.warned.add(origin);
+        this.logger.warn(`Node ${origin} has no session metrics route (answered ${status}): an older Xenon. ` +
+            'Its sessions show no CPU or memory. Upgrade the node.');
+    }
+};
+exports.NodeMetricsSupport = NodeMetricsSupport;
+exports.NodeMetricsSupport = NodeMetricsSupport = __decorate([
+    (0, typedi_1.Service)()
+], NodeMetricsSupport);

package/lib/src/sessions/RemoteSession.js

@@ -18,6 +18,7 @@ const typedi_1 = require("typedi");
 const logger_1 = __importDefault(require("../logger"));
 const SessionType_1 = __importDefault(require("../enums/SessionType"));
 const hubSessionToken_1 = require("../gateway/hubSessionToken");
+const nodeMetrics_1 = require("../services/metrics/nodeMetrics");
 const nodeSessionStatus_1 = require("../gateway/nodeSessionStatus");
 const XenonSession_1 = require("./XenonSession");
 class RemoteSession extends XenonSession_1.XenonSession {
@@ -221,6 +222,37 @@ class RemoteSession extends XenonSession_1.XenonSession {
             return null;
         }
     }
+    /** The node's origin, where its own routes are; null for a base URL that isn't one. */
+    nodeOrigin() {
+        try {
+            return new URL(this.baseUrl).origin;
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    /** The node's CPU and memory for this session newer than `after` (NodeMetricsCollector). */
+    nodeMetrics(after) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const origin = this.nodeOrigin();
+            if (!origin)
+                return { kind: 'unavailable', reason: `no node origin in ${this.baseUrl}` };
+            try {
+                const response = yield this.call({
+                    method: 'get',
+                    url: `${origin}/xenon/api/node/sessions/${encodeURIComponent(this.sessionId)}/metrics`,
+                    params: after === null ? undefined : { after },
+                    timeout: 5000,
+                    validateStatus: () => true,
+                });
+                return (0, nodeMetrics_1.readNodeMetricsReply)(response.status, (_a = response.headers) !== null && _a !== void 0 ? _a : {}, response.data);
+            }
+            catch (err) {
+                return { kind: 'unavailable', reason: String((_c = (_b = err === null || err === void 0 ? void 0 : err.code) !== null && _b !== void 0 ? _b : err === null || err === void 0 ? void 0 : err.message) !== null && _c !== void 0 ? _c : err) };
+            }
+        });
+    }
     /**
      * Whether the node still has this session. The node is asked with its
      * session-status route (gateway/nodeSessionStatus.ts), which reads Appium's