@xenon-device-management/xenon 2.10.0 → 2.11.0

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/services/selector-health/selectorDetail.js

@@ -41,6 +41,23 @@ function bump(m, key, make) {
 const topCounts = (m) => Array.from(m.values())
     .sort((a, b) => b.count - a.count)
     .slice(0, TOP);
+/** The sessions behind these ids, with their phone and build, by id. */
+function sessionsById(ids) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const parts = yield Promise.all((0, selectorKeys_1.chunk)(ids).map((part) => prisma_1.prisma.session.findMany({
+            where: { id: { in: part } },
+            select: {
+                id: true,
+                build_id: true,
+                device_udid: true,
+                device_name: true,
+                device_platform: true,
+                build: { select: { name: true } },
+            },
+        })));
+        return new Map(parts.flat().map((s) => [s.id, s]));
+    });
+}
 /**
  * Everything the panel shows for one selector over the period, or null when
  * the caller may not see it (a member, and no session they can see healed
@@ -61,7 +78,10 @@ function selectorDetail(query_1, scope_1) {
                     (0, selectorKeys_1.sessionScope)(scope),
                 ],
             },
-            orderBy: { createdAt: 'desc' },
+            orderBy: [{ createdAt: 'desc' }, { id: 'desc' }],
+            // Each heal's own fields only. Attaching its session to every heal took
+            // most of a second for a selector healed 50,000 times in a year; each
+            // session is read once instead.
             select: {
                 id: true,
                 session_id: true,
@@ -71,17 +91,9 @@ function selectorDetail(query_1, scope_1) {
                 healing_tier: true,
                 healing_confidence: true,
                 duration: true,
-                session: {
-                    select: {
-                        build_id: true,
-                        device_udid: true,
-                        device_name: true,
-                        device_platform: true,
-                        build: { select: { name: true } },
-                    },
-                },
             },
         });
+        const sessionOf = yield sessionsById(Array.from(new Set(rows.map((r) => r.session_id))));
         const sessions = new Set();
         let timeSpentMs = 0;
         const fixes = new Map();
@@ -110,20 +122,23 @@ function selectorDetail(query_1, scope_1) {
                 }
                 fixes.set(fixKey, f);
             }
-            const platform = r.session.device_platform || 'unknown';
+            const session = sessionOf.get(r.session_id);
+            if (!session)
+                continue;
+            const platform = session.device_platform || 'unknown';
             bump(platforms, platform, () => ({ name: platform, count: 0 }));
-            const buildId = (_e = r.session.build_id) !== null && _e !== void 0 ? _e : null;
+            const buildId = (_e = session.build_id) !== null && _e !== void 0 ? _e : null;
             bump(builds, buildId !== null && buildId !== void 0 ? buildId : '', () => {
                 var _a;
                 return ({
                     id: buildId,
-                    name: ((_a = r.session.build) === null || _a === void 0 ? void 0 : _a.name) || buildId || 'No build',
+                    name: ((_a = session.build) === null || _a === void 0 ? void 0 : _a.name) || buildId || 'No build',
                     count: 0,
                 });
             });
-            const udid = r.session.device_udid;
+            const udid = session.device_udid;
             if (udid)
-                bump(devices, udid, () => ({ udid, name: r.session.device_name || udid, count: 0 }));
+                bump(devices, udid, () => ({ udid, name: session.device_name || udid, count: 0 }));
         }
         const [state, events] = yield Promise.all([
             prisma_1.prisma.selectorState.findUnique({
@@ -168,17 +183,18 @@ function selectorDetail(query_1, scope_1) {
             devices: topCounts(devices),
             recent: rows.slice(0, RECENT).map((r) => {
                 var _a, _b, _c, _d;
-                return ({
+                const session = sessionOf.get(r.session_id);
+                return {
                     id: r.id,
                     sessionId: r.session_id,
-                    buildId: (_a = r.session.build_id) !== null && _a !== void 0 ? _a : null,
+                    buildId: (_a = session === null || session === void 0 ? void 0 : session.build_id) !== null && _a !== void 0 ? _a : null,
                     at: r.createdAt.toISOString(),
-                    device: r.session.device_name || r.session.device_udid || null,
-                    platform: r.session.device_platform || null,
+                    device: (session === null || session === void 0 ? void 0 : session.device_name) || (session === null || session === void 0 ? void 0 : session.device_udid) || null,
+                    platform: (session === null || session === void 0 ? void 0 : session.device_platform) || null,
                     method: (_b = r.healing_tier) !== null && _b !== void 0 ? _b : null,
                     confidence: (_c = r.healing_confidence) !== null && _c !== void 0 ? _c : null,
                     healedSelector: (_d = r.healed_selector) !== null && _d !== void 0 ? _d : null,
-                });
+                };
             }),
             state: (0, stateView_1.stateView)(state, {
                 fixed: fixedEvent ? { user_id: fixedEvent.user_id } : undefined,

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