@xenon-device-management/xenon 2.16.0 → 2.17.0

package/lib/src/app/openapi/grid.yaml

@@ -1736,6 +1736,82 @@ paths:
           $ref: '#/components/responses/GridNodeUnknownSession'
         '503':
           $ref: '#/components/responses/GridNodeTokenUnavailable'
+  /api/node/sessions/{sessionId}/device-logs:
+    get:
+      operationId: getGridNodeSessionDeviceLogs
+      summary: Collect a session's device log lines from this node
+      description: |
+        Node only: a hub collects the device log lines a node has recorded
+        for a session on one of its phones, as soon as the session is
+        created, every 10 s after that, and once more when the session
+        ends. The hub writes them as the session's Device logs. Only a
+        server started with `hub` set has this route.
+
+        The node records each session its hub created, with the same limit
+        as a session on the hub's own phone (10,000 lines, then up to 2,000
+        more errors), and keeps the lines in memory until the hub collects
+        them, an ended session's for 10 minutes. If no hub asks within 2
+        minutes of the start, the node stops recording that session.
+
+        Each line has a number, `seq`, counting up from 1. `after` asks for
+        the lines after that number, and the node drops the others, so a
+        later call never returns them again. An answer holds at most 2,000
+        lines; `more` says the node has others, to ask for at once. `state`
+        is `recording`, `ended`, or `off` (the node doesn't record this
+        session). `timestamp` is the line's moment by the node's clock.
+
+        It is answered before the login, with the same rule as
+        `GET /api/node/sessions/{sessionId}`: no credential with
+        per-command auth off or auth disabled, otherwise the hub's session
+        token for that session. Every answer from a node carries
+        `x-xenon-node-device-logs: 1`. It isn't rate-limited.
+      tags:
+        - Hub-Node
+      security:
+        - HubToken: []
+        - {}
+      parameters:
+        - $ref: '#/components/parameters/GridNodeSessionId'
+        - in: query
+          name: after
+          required: false
+          description: A line number; only later lines are returned, and the others are dropped. Anything that isn't a plain number is ignored.
+          schema:
+            type: integer
+            example: 2000
+      responses:
+        '200':
+          description: The session's lines.
+          headers:
+            x-xenon-node-device-logs:
+              description: Always `1` on a node.
+              schema:
+                type: string
+                example: '1'
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  value:
+                    $ref: '#/components/schemas/GridNodeDeviceLogs'
+              example:
+                value:
+                  state: recording
+                  more: false
+                  lines:
+                    - seq: 2001
+                      message: '10-05 14:20:02.114  4127  4127 I ActivityManager: Start proc 4127:com.example.shop/u0a215'
+                      timestamp: 1791111602114
+                    - seq: 2002
+                      message: '10-05 14:20:02.391  4127  4127 E AndroidRuntime: FATAL EXCEPTION: main'
+                      timestamp: 1791111602391
+        '401':
+          $ref: '#/components/responses/GridNotANodeUnauthorized'
+        '404':
+          $ref: '#/components/responses/GridNodeUnknownSession'
+        '503':
+          $ref: '#/components/responses/GridNodeTokenUnavailable'
   /api/status:
     get:
       operationId: getGridServerStatus
@@ -2304,6 +2380,32 @@ components:
                 type: string
                 nullable: true
                 description: The app the app figures are for (Android), else null.
+    GridNodeDeviceLogs:
+      type: object
+      properties:
+        state:
+          type: string
+          enum:
+            - recording
+            - ended
+            - 'off'
+        more:
+          type: boolean
+          description: The node holds more lines than this answer; ask again with the last `seq`.
+        lines:
+          type: array
+          items:
+            type: object
+            properties:
+              seq:
+                type: integer
+                description: The line's number in the session, from 1.
+              message:
+                type: string
+                description: The line as the device printed it.
+              timestamp:
+                type: integer
+                description: Epoch milliseconds, by the node's clock.
     GridWebDriverError:
       type: object
       description: A WebDriver-style error, as Appium answers one.

package/lib/src/dashboard/event-manager.js

@@ -79,6 +79,7 @@ const NotificationService_1 = require("../services/NotificationService");
 const SessionMetricsService_1 = require("../services/metrics/SessionMetricsService");
 const SessionDeviceLogs_1 = require("../services/logcat/SessionDeviceLogs");
 const nodeMetrics_1 = require("../services/metrics/nodeMetrics");
+const nodeDeviceLogs_1 = require("../services/logcat/nodeDeviceLogs");
 const sessionCommandSummary_1 = require("./sessionCommandSummary");
 const commandLogFields_1 = require("./commandLogFields");
 const typedi_2 = require("typedi");
@@ -156,19 +157,15 @@ let DashboardEventManager = class DashboardEventManager {
             // once its row exists (the lines point at it), unless the session turned
             // it off: an Android phone's stream, or the log an iPhone's or
             // simulator's driver captures. Not waited for: an Android phone's clock
-            // and log stream are read in the background.
+            // and log stream are read in the background. A node's phone's lines are
+            // collected from the node, through the session.
             const deviceLogs = typedi_1.Container.get(SessionDeviceLogs_1.SessionDeviceLogs);
             if (capabilities[XenonCapabilityManager_1.XENON_CAPABILITIES.SAVE_DEVICE_LOGS] === false) {
                 void deviceLogs.noteOff(session.getId());
             }
             else {
-                void deviceLogs.start({
-                    sessionId: session.getId(),
-                    device,
-                    since: session.allocatedAt,
-                    driverLog: (_d = (_c = session).deviceLog) === null || _d === void 0 ? void 0 : _d.call(_c),
-                    appUnderTest: (_f = (_e = session).appUnderTest) === null || _f === void 0 ? void 0 : _f.call(_e),
-                });
+                const deviceLogSource = (0, nodeDeviceLogs_1.nodeDeviceLogsSourceOf)(session);
+                void deviceLogs.start(Object.assign({ sessionId: session.getId(), device, since: session.allocatedAt, driverLog: (_d = (_c = session).deviceLog) === null || _d === void 0 ? void 0 : _d.call(_c), appUnderTest: (_f = (_e = session).appUnderTest) === null || _f === void 0 ? void 0 : _f.call(_e) }, (deviceLogSource ? { source: deviceLogSource } : {})));
             }
             // Emit session started event
             void typedi_1.Container.get(SocketServer_1.SocketServer).emitToDashboardForDevices(SocketEvents_1.SocketEvents.SESSION_STARTED, Object.assign(Object.assign({}, createData), { status: 'running', build_name: buildName }), { udid: device.udid });

package/lib/src/device-utils.js

@@ -275,8 +275,17 @@ function allocateDeviceForSession(capability_1, deviceTimeOutMs_1, deviceQueryIn
         // We have a locked device here
         if (device !== null) {
             const lockedDevice = device;
-            // Principal Health Check Integration: Ensure device is READY before allocation
-            if (!lockedDevice.cloud) {
+            // Ready for a session: asked only of a phone this server drives. The
+            // check is this machine's (an iPhone's WebDriverAgent on 127.0.0.1, and a
+            // go-ios stream started to recover it). Another server's phone, a node's
+            // on a hub, is checked by that server when it allocates the phone the hub
+            // pins. Through 2.15 the hub checked it too: with the node on another
+            // machine nothing answered and the session was refused as unhealthy, and
+            // with both on one Mac the hub started a WebDriverAgent of its own on the
+            // node's iPhone.
+            const context = typedi_1.Container.get(PluginContext_1.PluginContext);
+            const ownPhone = (0, localDeviceHosts_1.isOwnDevice)((0, localDeviceHosts_1.localDeviceHosts)(context.pluginArgs, context.port), context.nodeId, lockedDevice);
+            if (!lockedDevice.cloud && ownPhone) {
                 const platform = lockedDevice.platform.toLowerCase();
                 const managers = yield getDeviceManager().deviceInstances();
                 const manager = managers.find((m) => {

package/lib/src/gateway/nodeAsk.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OlderNodes = exports.OLDER_NODE_RECHECK_MS = void 0;
+exports.readNodeReply = readNodeReply;
+/**
+ * The node's answer at a route whose answers carry `header`. `answerOf` reads
+ * a 200's `value`, or returns null when it isn't one.
+ */
+function readNodeReply(header, status, headers, data, answerOf) {
+    if (!(headers === null || headers === void 0 ? void 0 : headers[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 answer = status === 200 ? answerOf(data === null || data === void 0 ? void 0 : data.value) : null;
+    if (answer !== null)
+        return { kind: 'answer', answer };
+    return { kind: 'unavailable', reason: `answered ${status}` };
+}
+/** How long a hub leaves a node without a route alone before asking it again. */
+exports.OLDER_NODE_RECHECK_MS = 10 * 60000;
+/**
+ * Hub side: which nodes lack a route (an older Xenon). Their sessions go
+ * without what the route serves; the hub says so once per node, and asks
+ * again after OLDER_NODE_RECHECK_MS, so a node upgraded in place is picked
+ * up without restarting the hub.
+ */
+class OlderNodes {
+    constructor() {
+        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.OLDER_NODE_RECHECK_MS);
+        if (this.warned.has(origin))
+            return;
+        this.warned.add(origin);
+        this.logger.warn(this.warning(origin, status));
+    }
+}
+exports.OlderNodes = OlderNodes;

package/lib/src/gateway/nodeSessionDeviceLogs.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeSessionDeviceLogsHandler = nodeSessionDeviceLogsHandler;
+exports.registerNodeSessionDeviceLogs = registerNodeSessionDeviceLogs;
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../logger"));
+const config_1 = require("../config");
+const commandAuth_1 = require("../middleware/commandAuth");
+const nodeDeviceLogs_1 = require("../services/logcat/nodeDeviceLogs");
+const NodeDeviceLogStore_1 = require("../services/logcat/NodeDeviceLogStore");
+const hubSessionToken_1 = require("./hubSessionToken");
+const nodeSessionMetrics_1 = require("./nodeSessionMetrics");
+const nodeSessionStatus_1 = require("./nodeSessionStatus");
+function nodeSessionDeviceLogsHandler(deps) {
+    return (req, res) => {
+        var _a, _b;
+        res.setHeader(nodeDeviceLogs_1.NODE_DEVICE_LOGS_HEADER, '1');
+        const sessionId = String((_b = (_a = req.params) === null || _a === void 0 ? void 0 : _a.sessionId) !== null && _b !== void 0 ? _b : '');
+        (0, nodeSessionStatus_1.answerForHub)(deps, req, res, sessionId, 'Session device logs', () => { var _a; return res.status(200).json({ value: deps.read(sessionId, (0, nodeSessionMetrics_1.parseAfter)((_a = req.query) === null || _a === void 0 ? void 0 : _a.after)) }); });
+    };
+}
+/** A node's route, ahead of its login, like the session-status route. A hub or standalone server has none. */
+function registerNodeSessionDeviceLogs(router, pluginArgs) {
+    if (pluginArgs.hub === undefined)
+        return;
+    router.get(nodeDeviceLogs_1.NODE_DEVICE_LOGS_ROUTE, nodeSessionDeviceLogsHandler({
+        hubTokens: new hubSessionToken_1.HubSessionTokenVerifier(pluginArgs.hub),
+        enforced: () => (0, commandAuth_1.commandAuthEnabled)() && config_1.config.authDisabled !== true,
+        read: (sessionId, after) => typedi_1.Container.get(NodeDeviceLogStore_1.NodeDeviceLogStore).read(sessionId, after),
+        logger: logger_1.default.scope('NodeSessionDeviceLogs'),
+    }));
+}

package/lib/src/plugin.js

@@ -68,6 +68,7 @@ const appiumUmbrella_1 = require("./sessions/appiumUmbrella");
 const LiveSessionOwners_1 = require("./services/device-access/LiveSessionOwners");
 const sessionMemory_1 = require("./sessions/sessionMemory");
 const SessionMetricsService_1 = require("./services/metrics/SessionMetricsService");
+const SessionDeviceLogs_1 = require("./services/logcat/SessionDeviceLogs");
 const PhoneNetworkRestore_1 = require("./services/network/PhoneNetworkRestore");
 const config_1 = require("./config");
 const SessionManager_1 = require("./sessions/SessionManager");
@@ -120,8 +121,10 @@ class XenonPlugin extends base_plugin_1.default {
                     reason: (0, shutdownReason_1.unexpectedShutdownReason)(cause),
                 });
             }
-            if (sessionId)
+            if (sessionId) {
                 yield typedi_1.Container.get(SessionMetricsService_1.SessionMetricsService).stop(sessionId);
+                yield typedi_1.Container.get(SessionDeviceLogs_1.SessionDeviceLogs).stop(sessionId);
+            }
             // Appium's new-command timeout ends a session here, not in deleteSession:
             // the phone's network (profile, interceptor proxy) and the capture are
             // put back before the phone is released.

package/lib/src/scripts/initialize-database.js

@@ -30,18 +30,12 @@ const run_migrations_1 = require("./run-migrations");
  * prisma/schema.prisma's provider to `databaseProvider`. With `postgresql`,
  * that left a PostgreSQL schema in the checkout that the SQLite file couldn't
  * use.
- *
- * It first warns of changes to prisma/schema.prisma that no migration makes.
- * `npm run db:generate` gives the developer's database a migration history, and
- * from then on it is updated with `migrate deploy`, which never applies them,
- * while the log said the schema was in sync.
  */
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
         // A PostgreSQL URL would otherwise reach the history read and fail there,
         // under a message about the file.
         (0, database_check_1.assertSupportedDatabase)();
-        (0, run_migrations_1.warnOfUnmigratedSchemaChanges)();
         yield (0, run_migrations_1.syncDatabaseSchema)();
         logger_1.default.info('[DBInit] Generating Prisma Client...');
         (0, node_child_process_1.execSync)('npx prisma generate', {