@xenon-device-management/xenon 2.16.0 → 2.17.0

package/lib/src/services/logcat/SessionDeviceLogs.js

@@ -26,6 +26,9 @@ const PluginContext_1 = require("../../PluginContext");
 const localDeviceHosts_1 = require("../../device-managers/localDeviceHosts");
 const LogcatStreamService_1 = require("../../device-managers/android/LogcatStreamService");
 const adbForPhone_1 = require("../network/adbForPhone");
+const NodeDeviceLogStore_1 = require("./NodeDeviceLogStore");
+const NodeDeviceLogsCollector_1 = require("./NodeDeviceLogsCollector");
+const nodeDeviceLogs_1 = require("./nodeDeviceLogs");
 const deviceLogBook_1 = require("./deviceLogBook");
 const iosDriverLog_1 = require("./iosDriverLog");
 /** How often a session's new lines are written. */
@@ -37,6 +40,11 @@ const CLOCK_TIMEOUT_MS = 5000;
 /** Waits before opening the phone's log stream again: doubling from the first, up to the last. */
 const RETRY_FIRST_MS = 1000;
 const RETRY_MAX_MS = 30000;
+/**
+ * The newest stored rows a hub reads when its collection resumes after a
+ * restart, to find where they end in the node's first answer.
+ */
+const RESUME_TAIL = 32;
 /**
  * The session page's Device logs for a session on this server's own Android
  * phone, iPhone or simulator: its lines from start to end, each once, with
@@ -58,6 +66,14 @@ const RETRY_MAX_MS = 30000;
  * ostrace`): that one has no simulators, needs the phone's go-ios tunnel on
  * iOS 17+, serves one reader per phone and carries ten times the lines.
  *
+ * A node records the sessions its hub creates the same way, whatever its
+ * dashboard setting, but has no Session row for them: it holds the rows in
+ * memory (NodeDeviceLogStore) for the hub to collect, and stops recording a
+ * session no hub has asked about within UNCLAIMED_MS (a hub with its
+ * dashboard off never asks). On a hub, a session on a node's phone gets a
+ * NodeDeviceLogsCollector instead, which asks the node for the rows and
+ * writes them here, in the order the node kept them.
+ *
  * Until 2.14 each recorded command dumped the last 500 lines (`logcat -d`),
  * kept the last 100 and skipped as many as the previous dump had given, so
  * after the first command nothing more was ever saved, each line stamped with
@@ -68,73 +84,184 @@ let SessionDeviceLogs = class SessionDeviceLogs {
     constructor() {
         this.log = logger_1.default.scope('DeviceLogs');
         this.running = new Map();
+        /** Stops under way: a second ending waits for the first one's last lines. */
+        this.stopping = new Map();
     }
     /**
      * Whether a session on this device is recorded: an Android phone or
-     * emulator, an iPhone or a simulator, that this server drives.
+     * emulator, an iPhone or a simulator, that this server drives, or, on a
+     * hub, a node's through its session.
      */
-    appliesTo(device) {
+    appliesTo(device, source) {
         var _a;
         if (!device || device.cloud)
             return false;
         if (!['android', 'ios', 'tvos'].includes(String((_a = device.platform) !== null && _a !== void 0 ? _a : '').toLowerCase())) {
             return false;
         }
+        if (this.ownPhone(device))
+            return true;
         // A node's phone isn't reachable from here (its driver and its adb are
-        // the node's); the node has the session, and no row for it.
+        // the node's): on a hub, its lines are collected from the node. Never a
+        // cloud provider's (above).
+        return !!source && !this.holdsForHub();
+    }
+    ownPhone(device) {
         const ctx = this.context();
         return (0, localDeviceHosts_1.isOwnDevice)((0, localDeviceHosts_1.localDeviceHosts)(ctx.pluginArgs, ctx.port), ctx.nodeId, device);
     }
     /**
      * Starts recording the session's device log. Resolves once it listens to
-     * the phone's stream (or is waiting to try again); callers needn't wait.
+     * the phone's stream (or is waiting to try again), or asks the node;
+     * callers needn't wait.
      */
-    start({ sessionId, device, since, driverLog, appUnderTest }) {
-        var _a, _b;
-        if (this.running.has(sessionId) || !this.appliesTo(device))
+    start({ sessionId, device, since, source, resume, driverLog, appUnderTest, }) {
+        var _a, _b, _c, _d;
+        if (this.running.has(sessionId) || !this.appliesTo(device, source))
             return Promise.resolve();
+        const fromNode = !!source && !this.ownPhone(device);
         const android = String(device.platform).toLowerCase() === 'android';
-        if (!android && !(0, iosDriverLog_1.isDriverLog)(driverLog)) {
+        if (!fromNode && !android && !(0, iosDriverLog_1.isDriverLog)(driverLog)) {
             this.log.info(`[${sessionId}] No device log for ${device.udid}: the driver isn't capturing one ` +
                 '(appium:skipLogCapture?)');
             return Promise.resolve();
         }
+        // A node has no Session row for the hub's sessions, so it holds the rows
+        // for its hub to collect (GET /node/sessions/:id/device-logs).
+        const held = this.holdsForHub();
         const entry = {
             udid: device.udid,
             buffer: [],
-            flushTimer: setInterval(() => void this.write(sessionId, entry), this.flushIntervalMs()),
             writing: Promise.resolve(),
             lastCreatedAt: 0,
             attempts: 0,
             stopped: false,
+            held,
         };
-        (_b = (_a = entry.flushTimer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+        if (!held) {
+            entry.flushTimer = setInterval(() => void this.write(sessionId, entry), this.flushIntervalMs());
+            (_b = (_a = entry.flushTimer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+        }
         this.running.set(sessionId, entry);
+        const warn = (err) => { var _a; return this.log.warn(`[${sessionId}] Device log not recorded: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`); };
+        if (fromNode) {
+            this.log.info(`[${sessionId}] Collecting the device log of ${device.udid} from its node`);
+            entry.collecting = this.collect(sessionId, entry, source, resume === true).catch(warn);
+            return entry.collecting;
+        }
+        if (held) {
+            this.nodeStore().begin(sessionId);
+            entry.unclaimedTimer = setTimeout(() => this.dropUnclaimed(sessionId), this.unclaimedMs());
+            (_d = (_c = entry.unclaimedTimer).unref) === null || _d === void 0 ? void 0 : _d.call(_c);
+        }
         this.log.info(`[${sessionId}] Recording the device log of ${device.udid}`);
         const opened = android
             ? this.open(sessionId, entry, since !== null && since !== void 0 ? since : Date.now())
             : Promise.resolve(this.listenToDriver(sessionId, entry, since !== null && since !== void 0 ? since : Date.now(), driverLog, appUnderTest));
-        return opened.catch((err) => { var _a; return this.log.warn(`[${sessionId}] Device log not recorded: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`); });
+        return opened.catch(warn);
     }
-    /** Stops listening and writes what is left. Idempotent. */
+    /**
+     * Stops listening and writes what is left (on a node, holds it for the
+     * hub). Idempotent: a stop while one is under way resolves with it, once
+     * the last lines are written, since what follows an ending (the failure
+     * analysis) reads them.
+     */
     stop(sessionId) {
+        const underway = this.stopping.get(sessionId);
+        if (underway)
+            return underway;
+        const entry = this.running.get(sessionId);
+        if (!entry)
+            return Promise.resolve();
+        const done = this.finishStop(sessionId, entry).finally(() => this.stopping.delete(sessionId));
+        this.stopping.set(sessionId, done);
+        return done;
+    }
+    finishStop(sessionId, entry) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const entry = this.running.get(sessionId);
-            if (!entry)
-                return;
-            this.running.delete(sessionId);
-            entry.stopped = true;
-            clearInterval(entry.flushTimer);
-            if (entry.retryTimer)
-                clearTimeout(entry.retryTimer);
-            (_a = entry.remove) === null || _a === void 0 ? void 0 : _a.call(entry);
-            entry.remove = undefined;
+            this.halt(sessionId, entry);
+            // On a hub: the node's last lines. Its session ended first (the hub's
+            // DELETE reached it), so they are all there.
+            if (entry.collecting)
+                yield entry.collecting;
+            if (entry.collector)
+                yield entry.collector.stop();
             if (entry.book)
-                entry.buffer.push(...entry.book.finish(new Date()));
-            yield this.write(sessionId, entry);
+                this.keep(sessionId, entry, entry.book.finish(new Date()));
+            if (entry.held)
+                this.nodeStore().end(sessionId);
+            else
+                yield this.write(sessionId, entry);
+        });
+    }
+    /** Stops listening, with nothing more written or held. */
+    halt(sessionId, entry) {
+        var _a;
+        this.running.delete(sessionId);
+        entry.stopped = true;
+        if (entry.flushTimer)
+            clearInterval(entry.flushTimer);
+        if (entry.retryTimer)
+            clearTimeout(entry.retryTimer);
+        if (entry.unclaimedTimer)
+            clearTimeout(entry.unclaimedTimer);
+        (_a = entry.remove) === null || _a === void 0 ? void 0 : _a.call(entry);
+        entry.remove = undefined;
+    }
+    /**
+     * On a node: no hub has asked about the session since it started, so none
+     * collects it (a hub with its dashboard off, the default, or an older
+     * one). Recording it would run the phone's log stream and hold up to the
+     * book's limit for nothing.
+     */
+    dropUnclaimed(sessionId) {
+        const entry = this.running.get(sessionId);
+        if (!entry || this.nodeStore().claimed(sessionId))
+            return;
+        this.halt(sessionId, entry);
+        this.nodeStore().forget(sessionId);
+        this.log.debug(`[${sessionId}] No hub asked for the device log of ${entry.udid}; stopped recording it`);
+    }
+    /**
+     * On a hub: asks the node for the session's lines and writes each answer's
+     * at once. After a restart, new rows go after the newest ones stored.
+     */
+    collect(sessionId, entry, source, resume) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let tail = [];
+            if (resume) {
+                try {
+                    tail = yield this.storedTail(sessionId);
+                }
+                catch (err) {
+                    this.log.warn(`[${sessionId}] Can't read the newest device log lines stored: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+                }
+                if (tail.length > 0)
+                    entry.lastCreatedAt = tail[tail.length - 1].createdAt;
+            }
+            entry.collector = this.collectorFor(source, (rows) => {
+                this.keep(sessionId, entry, rows);
+                return this.write(sessionId, entry);
+            }, tail.map(({ message, timestamp }) => ({ message, timestamp })));
+            // Made even when the session ended meanwhile: its stop then asks the
+            // node once, for the last lines.
+            if (!entry.stopped)
+                entry.collector.start();
         });
     }
+    /** The session's new rows: held for the hub on a node, else written soon. */
+    keep(sessionId, entry, rows) {
+        if (rows.length === 0)
+            return;
+        if (entry.held) {
+            this.nodeStore().add(sessionId, rows);
+            return;
+        }
+        entry.buffer.push(...rows);
+        if (entry.buffer.length >= exports.WRITE_BATCH)
+            void this.write(sessionId, entry);
+    }
     /** Whether the session is recorded here. */
     isRecording(sessionId) {
         return this.running.has(sessionId);
@@ -207,12 +334,7 @@ let SessionDeviceLogs = class SessionDeviceLogs {
                     delivered = true;
                     entry.attempts = 0;
                 }
-                const rows = book.add(rec);
-                if (rows.length === 0)
-                    return;
-                entry.buffer.push(...rows);
-                if (entry.buffer.length >= exports.WRITE_BATCH)
-                    void this.write(sessionId, entry);
+                this.keep(sessionId, entry, book.add(rec));
             }, 
             // Never refused: what the session keeps is bounded by its book.
             () => true, () => {
@@ -224,7 +346,7 @@ let SessionDeviceLogs = class SessionDeviceLogs {
                 // A stream that delivered nothing (a phone that's gone) isn't noted
                 // again on every try.
                 if (delivered) {
-                    entry.buffer.push(...note);
+                    this.keep(sessionId, entry, note);
                     this.log.info(`[${sessionId}] The device log of ${entry.udid} ended; opening it again`);
                 }
                 this.retry(sessionId, entry);
@@ -246,12 +368,14 @@ let SessionDeviceLogs = class SessionDeviceLogs {
         entry.book = book;
         const appLines = appUnderTest ? new iosDriverLog_1.IosAppLines(appUnderTest) : undefined;
         if (appLines) {
-            entry.buffer.push({
-                message: `Xenon: Kept here: what the app under test (${appUnderTest}) logs itself, ` +
-                    'every error inside it, what the phone says about its launch, state, crashes ' +
-                    "and end, and faults. The rest of the phone's log is left out.",
-                timestamp: new Date(since),
-            });
+            this.keep(sessionId, entry, [
+                {
+                    message: `Xenon: Kept here: what the app under test (${appUnderTest}) logs itself, ` +
+                        'every error inside it, what the phone says about its launch, state, crashes ' +
+                        "and end, and faults. The rest of the phone's log is left out.",
+                    timestamp: new Date(since),
+                },
+            ]);
         }
         const take = (line) => {
             const rec = (0, iosDriverLog_1.recordFromDriverLog)(line);
@@ -259,12 +383,7 @@ let SessionDeviceLogs = class SessionDeviceLogs {
                 return;
             if (appLines && !appLines.keeps(rec.message, rec.level))
                 return;
-            const rows = book.add(rec);
-            if (rows.length === 0)
-                return;
-            entry.buffer.push(...rows);
-            if (entry.buffer.length >= exports.WRITE_BATCH)
-                void this.write(sessionId, entry);
+            this.keep(sessionId, entry, book.add(rec));
         };
         // The create's lines first teach the filter the app's process, so its
         // first lines aren't lost to an announcement that comes after them.
@@ -326,6 +445,42 @@ let SessionDeviceLogs = class SessionDeviceLogs {
     retryFirstMs() {
         return RETRY_FIRST_MS;
     }
+    /** A node (a server with `hub`) holds the rows 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(NodeDeviceLogStore_1.NodeDeviceLogStore);
+    }
+    unclaimedMs() {
+        return nodeDeviceLogs_1.UNCLAIMED_MS;
+    }
+    collectorFor(source, onLines, storedTail) {
+        return new NodeDeviceLogsCollector_1.NodeDeviceLogsCollector({
+            source,
+            onLines,
+            storedTail,
+            support: typedi_1.Container.get(nodeDeviceLogs_1.NodeDeviceLogsSupport),
+            logger: this.log,
+        });
+    }
+    /** The session's newest Device logs rows, by `createdAt`, oldest first. */
+    storedTail(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rows = yield prisma_1.prisma.log.findMany({
+                where: { session_id: sessionId, log_type: 'DEVICE' },
+                orderBy: { createdAt: 'desc' },
+                take: RESUME_TAIL,
+                select: { message: true, timestamp: true, createdAt: true },
+            });
+            return rows.reverse().map((row) => ({
+                message: row.message,
+                timestamp: row.timestamp.getTime(),
+                createdAt: row.createdAt.getTime(),
+            }));
+        });
+    }
     /** The phone's clock against this server's, or null if its answer isn't one. */
     readClock(udid) {
         return __awaiter(this, void 0, void 0, function* () {

package/lib/src/services/logcat/nodeDeviceLogs.js

@@ -0,0 +1,91 @@
+"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.NodeDeviceLogsSupport = exports.UNCLAIMED_MS = exports.NODE_DEVICE_LOGS_KEEP_AFTER_END_MS = exports.NODE_DEVICE_LOG_PAGE = exports.NODE_DEVICE_LOGS_HEADER = exports.NODE_DEVICE_LOGS_ROUTE = void 0;
+exports.readNodeDeviceLogsReply = readNodeDeviceLogsReply;
+exports.nodeDeviceLogsSourceOf = nodeDeviceLogsSourceOf;
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../../logger"));
+const SessionType_1 = __importDefault(require("../../enums/SessionType"));
+const nodeAsk_1 = require("../../gateway/nodeAsk");
+/** Where a node serves a session's device log lines, under `/xenon/api`. */
+exports.NODE_DEVICE_LOGS_ROUTE = '/node/sessions/:sessionId/device-logs';
+/** On every answer of that route, so a hub can tell a node that has it. */
+exports.NODE_DEVICE_LOGS_HEADER = 'x-xenon-node-device-logs';
+/** Lines in one answer. */
+exports.NODE_DEVICE_LOG_PAGE = 2000;
+/** How long a node keeps an ended session's lines for its hub's last ask. */
+exports.NODE_DEVICE_LOGS_KEEP_AFTER_END_MS = 10 * 60000;
+/**
+ * A node stops recording a session no hub has asked about this long after
+ * it started: its hub doesn't collect (its dashboard is off, the default) or
+ * is older. A hub that collects asks as soon as the session is created.
+ */
+exports.UNCLAIMED_MS = 2 * 60000;
+const STATES = ['recording', 'ended', 'off'];
+/**
+ * The line, field by field, or null when it isn't one: one malformed row
+ * would fail every later write of the session's lines (a failed batch goes
+ * back to the front of the buffer).
+ */
+function lineOf(v) {
+    if (!v || typeof v !== 'object')
+        return null;
+    if (!Number.isSafeInteger(v.seq) || v.seq < 1)
+        return null;
+    if (typeof v.message !== 'string')
+        return null;
+    if (typeof v.timestamp !== 'number' || !Number.isFinite(v.timestamp))
+        return null;
+    return { seq: v.seq, message: v.message, timestamp: v.timestamp };
+}
+function deviceLogsAnswerOf(value) {
+    if (!value || !STATES.includes(value.state) || !Array.isArray(value.lines))
+        return null;
+    return {
+        state: value.state,
+        lines: value.lines.map(lineOf).filter((x) => !!x),
+        more: value.more === true,
+    };
+}
+function readNodeDeviceLogsReply(status, headers, data) {
+    return (0, nodeAsk_1.readNodeReply)(exports.NODE_DEVICE_LOGS_HEADER, status, headers, data, deviceLogsAnswerOf);
+}
+/**
+ * The session as a NodeDeviceLogsSource, when it runs on a node. A cloud
+ * provider's session (CloudSession) and this server's own (LocalSession)
+ * inherit the methods from RemoteSession, so the type decides.
+ */
+function nodeDeviceLogsSourceOf(session) {
+    var _a;
+    const s = session;
+    return s &&
+        ((_a = s.getType) === null || _a === void 0 ? void 0 : _a.call(s)) === SessionType_1.default.REMOTE &&
+        typeof s.nodeDeviceLogs === 'function' &&
+        typeof s.nodeOrigin === 'function'
+        ? s
+        : undefined;
+}
+/** Hub side: which nodes lack the route (an older Xenon). Their sessions have no Device logs. */
+let NodeDeviceLogsSupport = class NodeDeviceLogsSupport extends nodeAsk_1.OlderNodes {
+    constructor() {
+        super(...arguments);
+        this.logger = logger_1.default.scope('DeviceLogs');
+    }
+    warning(origin, status) {
+        return (`Node ${origin} has no session device log route (answered ${status}): an older Xenon. ` +
+            'Its sessions have no device logs here. Upgrade the node.');
+    }
+};
+exports.NodeDeviceLogsSupport = NodeDeviceLogsSupport;
+exports.NodeDeviceLogsSupport = NodeDeviceLogsSupport = __decorate([
+    (0, typedi_1.Service)()
+], NodeDeviceLogsSupport);

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

@@ -9,12 +9,13 @@ 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.NodeMetricsSupport = 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"));
 const SessionType_1 = __importDefault(require("../../enums/SessionType"));
+const nodeAsk_1 = require("../../gateway/nodeAsk");
 /** 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. */
@@ -41,33 +42,20 @@ function sampleOf(v) {
         return null;
     return { at: v.at, deviceCpuPct, deviceMemMb, deviceMemTotalMb, appCpuPct, appMemMb, appId };
 }
-function readNodeMetricsReply(status, headers, data) {
+function metricsAnswerOf(value) {
     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
-                    .map(sampleOf)
-                    .filter((x) => x !== null),
-            },
-        };
-    }
-    return { kind: 'unavailable', reason: `answered ${status}` };
+    if (!value || !STATES.includes(value.state) || !Array.isArray(value.samples))
+        return null;
+    return {
+        platform: String((_a = value.platform) !== null && _a !== void 0 ? _a : ''),
+        state: value.state,
+        samples: value.samples
+            .map(sampleOf)
+            .filter((x) => x !== null),
+    };
+}
+function readNodeMetricsReply(status, headers, data) {
+    return (0, nodeAsk_1.readNodeReply)(exports.NODE_METRICS_HEADER, status, headers, data, metricsAnswerOf);
 }
 /**
  * The session as a NodeMetricsSource, when it runs on a node. A cloud
@@ -84,35 +72,18 @@ function nodeMetricsSourceOf(session) {
         ? 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.
+ * OLDER_NODE_RECHECK_MS, so a node upgraded in place is picked up.
  */
-let NodeMetricsSupport = class NodeMetricsSupport {
+let NodeMetricsSupport = class NodeMetricsSupport extends nodeAsk_1.OlderNodes {
     constructor() {
+        super(...arguments);
         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. ` +
+    warning(origin, status) {
+        return (`Node ${origin} has no session metrics route (answered ${status}): an older Xenon. ` +
             'Its sessions show no CPU or memory. Upgrade the node.');
     }
 };

package/lib/src/sessions/RemoteSession.js

@@ -20,6 +20,7 @@ const SessionType_1 = __importDefault(require("../enums/SessionType"));
 const hubSessionToken_1 = require("../gateway/hubSessionToken");
 const outboundProxy_1 = require("../helpers/outboundProxy");
 const nodeMetrics_1 = require("../services/metrics/nodeMetrics");
+const nodeDeviceLogs_1 = require("../services/logcat/nodeDeviceLogs");
 const nodeSessionStatus_1 = require("../gateway/nodeSessionStatus");
 const XenonSession_1 = require("./XenonSession");
 class RemoteSession extends XenonSession_1.XenonSession {
@@ -235,6 +236,14 @@ class RemoteSession extends XenonSession_1.XenonSession {
     }
     /** The node's CPU and memory for this session newer than `after` (NodeMetricsCollector). */
     nodeMetrics(after) {
+        return this.askNode('metrics', after, nodeMetrics_1.readNodeMetricsReply);
+    }
+    /** The node's device log lines for this session after line `after` (NodeDeviceLogsCollector). */
+    nodeDeviceLogs(after) {
+        return this.askNode('device-logs', after, nodeDeviceLogs_1.readNodeDeviceLogsReply);
+    }
+    /** One of the node's routes about this session, `/xenon/api/node/sessions/<id>/<what>?after=`. */
+    askNode(what, after, read) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c;
             const origin = this.nodeOrigin();
@@ -243,12 +252,12 @@ class RemoteSession extends XenonSession_1.XenonSession {
             try {
                 const response = yield this.call({
                     method: 'get',
-                    url: `${origin}${nodeSessionStatus_1.NODE_SESSION_STATUS_PATH}/${encodeURIComponent(this.sessionId)}/metrics`,
+                    url: `${origin}${nodeSessionStatus_1.NODE_SESSION_STATUS_PATH}/${encodeURIComponent(this.sessionId)}/${what}`,
                     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);
+                return read(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) };

package/lib/src/sessions/SessionManager.js

@@ -59,9 +59,11 @@ const logger_1 = __importDefault(require("../logger"));
 const RemoteSession_1 = require("./RemoteSession");
 const CloudSession_1 = require("./CloudSession");
 const device_store_1 = require("../data-service/device-store");
+const PluginContext_1 = require("../PluginContext");
 const nodeWebDriverUrl_1 = require("../gateway/nodeWebDriverUrl");
 const XenonCapabilityManager_1 = require("../XenonCapabilityManager");
 const nodeMetrics_1 = require("../services/metrics/nodeMetrics");
+const nodeDeviceLogs_1 = require("../services/logcat/nodeDeviceLogs");
 // A session still running at boot that can't be picked up again is filed
 // under it; the failure analysis also writes it for a shutdown's drain.
 const failureCategories_1 = require("../dashboard/services/failureCategories");
@@ -121,7 +123,7 @@ let SessionManager = class SessionManager {
      */
     recoverActiveSessions(currentNodeId_1, nodeBasePath_1) {
         return __awaiter(this, arguments, void 0, function* (currentNodeId, nodeBasePath, isLocalHost = () => false) {
-            var _a, _b;
+            var _a, _b, _c;
             this.log.info('🔄 Attempting to recover active sessions from database...');
             try {
                 // Find all sessions that are still "running" (not ended)
@@ -225,6 +227,13 @@ let SessionManager = class SessionManager {
                         if (!device.cloud && dbSession.is_profiling_available) {
                             yield this.resumeNodeMetrics(dbSession.id, device, recoveredSession, sessionResponse);
                         }
+                        // Its device log too, where the hub records sessions (the dashboard
+                        // on) and the session didn't turn it off, after the newest line stored.
+                        if (!device.cloud &&
+                            ((_c = typedi_2.Container.get(PluginContext_1.PluginContext).pluginArgs) === null || _c === void 0 ? void 0 : _c.enableDashboard) &&
+                            xenonCapabilities[XenonCapabilityManager_1.XENON_CAPABILITIES.SAVE_DEVICE_LOGS] !== false) {
+                            yield this.resumeNodeDeviceLogs(dbSession.id, device, recoveredSession);
+                        }
                         recoveredCount++;
                     }
                     catch (sessionErr) {
@@ -266,6 +275,24 @@ let SessionManager = class SessionManager {
             }
         });
     }
+    /** Goes on collecting a node session's device log after a hub restart. */
+    resumeNodeDeviceLogs(sessionId, device, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Loaded here: SessionDeviceLogs imports the device managers.
+                const { SessionDeviceLogs } = yield Promise.resolve().then(() => __importStar(require('../services/logcat/SessionDeviceLogs')));
+                void typedi_2.Container.get(SessionDeviceLogs).start({
+                    sessionId,
+                    device,
+                    source: (0, nodeDeviceLogs_1.nodeDeviceLogsSourceOf)(session),
+                    resume: true,
+                });
+            }
+            catch (err) {
+                this.log.warn(`Session ${sessionId}: device log not resumed: ${err.message}`);
+            }
+        });
+    }
     /**
      * A recovered session is this process's from now on: its row's heartbeat
      * is stamped with this process, now. The row still carried the heartbeat