@xenon-device-management/xenon 2.15.0 → 2.17.0

package/lib/src/gateway/hubSessionToken.js

@@ -59,6 +59,7 @@ const jose = __importStar(require("jose"));
 const logger_1 = __importDefault(require("../logger"));
 const JwtKeyService_1 = require("../services/token/JwtKeyService");
 const singleUseLedger_1 = require("../services/token/singleUseLedger");
+const outboundProxy_1 = require("../helpers/outboundProxy");
 /**
  * The credential a hub's calls to a node carry.
  *
@@ -221,6 +222,22 @@ exports.HubSessionTokenIssuer = HubSessionTokenIssuer = __decorate([
 function hubJwksUrl(hub) {
     return new URL('/xenon/api/auth/jwks.json', hub);
 }
+/**
+ * A key lookup that fails after `ms`. jose's own timeout starts once its
+ * request has a socket, which a proxy agent hands it only after the proxy
+ * answers, so a proxy that never answers held every token check.
+ */
+function withinTime(getKey, ms) {
+    return (header, token) => {
+        let timer;
+        return Promise.race([
+            Promise.resolve(getKey(header, token)),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(`the hub's keys did not arrive in ${ms} ms`)), ms);
+            }),
+        ]).finally(() => clearTimeout(timer));
+    };
+}
 /** The node could not check a hub token (the hub's keys could not be fetched). */
 class HubTokenUnavailableError extends Error {
 }
@@ -251,15 +268,21 @@ function isVerdict(err) {
  * a token names a key it does not have (a hub that rotated its key).
  */
 class HubSessionTokenVerifier {
-    constructor(hubUrl, keys) {
+    constructor(hubUrl, keys, opts = {}) {
+        var _a;
         /** The create tokens already taken, by id, until each one expires. */
         this.usedCreates = new singleUseLedger_1.SingleUseLedger(exports.HUB_CREATE_TTL_SECONDS);
+        const jwksUrl = hubJwksUrl(hubUrl);
+        const timeoutMs = (_a = opts.timeoutMs) !== null && _a !== void 0 ? _a : 5000;
         this.keys =
-            keys !== null && keys !== void 0 ? keys : jose.createRemoteJWKSet(hubJwksUrl(hubUrl), {
-                timeoutDuration: 5000,
+            keys !== null && keys !== void 0 ? keys : withinTime(jose.createRemoteJWKSet(jwksUrl, {
+                timeoutDuration: timeoutMs,
                 cooldownDuration: 30000,
                 cacheMaxAge: 10 * 60000,
-            });
+                // The proxy the node's axios calls to its hub take; jose's own
+                // fetch takes none.
+                agent: (0, outboundProxy_1.proxyAgentFor)(jwksUrl),
+            }), timeoutMs);
     }
     verify(token, sessionId) {
         return __awaiter(this, void 0, void 0, function* () {

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/gateway/nodeWebDriverUrl.js

@@ -30,6 +30,7 @@ const logger_1 = __importDefault(require("../logger"));
 const helpers_1 = require("../helpers");
 const appiumBasePath_1 = require("../app/appiumBasePath");
 const PluginContext_1 = require("../PluginContext");
+const outboundProxy_1 = require("../helpers/outboundProxy");
 /**
  * Where a node's WebDriver API lives.
  *
@@ -95,11 +96,8 @@ let NodeBasePathResolver = class NodeBasePathResolver {
             let advertised;
             try {
                 const rejectUnauthorized = (_a = typedi_1.Container.get(PluginContext_1.PluginContext).pluginArgs) === null || _a === void 0 ? void 0 : _a.tlsRejectUnauthorized;
-                const response = yield axios_1.default.get(`${origin}${exports.WEBDRIVER_INFO_PATH}`, {
-                    timeout: exports.LOOKUP_TIMEOUT_MS,
-                    validateStatus: (status) => status === 200,
-                    httpsAgent: new https_1.default.Agent({ rejectUnauthorized: rejectUnauthorized !== false }),
-                });
+                const url = `${origin}${exports.WEBDRIVER_INFO_PATH}`;
+                const response = yield axios_1.default.get(url, Object.assign({ timeout: exports.LOOKUP_TIMEOUT_MS, validateStatus: (status) => status === 200, httpsAgent: new https_1.default.Agent({ rejectUnauthorized: rejectUnauthorized !== false }) }, (0, outboundProxy_1.axiosProxyConfig)(url, { rejectUnauthorized: rejectUnauthorized !== false })));
                 const basePath = (_b = response.data) === null || _b === void 0 ? void 0 : _b.basePath;
                 if (typeof basePath === 'string')
                     advertised = (0, appiumBasePath_1.normalizeBasePath)(basePath);

package/lib/src/helpers/outboundProxy.js

@@ -0,0 +1,219 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.outboundProxyFor = outboundProxyFor;
+exports.envProxyFor = envProxyFor;
+exports.proxyAgentFor = proxyAgentFor;
+exports.socketProxyAgentFor = socketProxyAgentFor;
+exports.axiosProxyConfig = axiosProxyConfig;
+const typedi_1 = require("typedi");
+const http_proxy_agent_1 = require("http-proxy-agent");
+const https_proxy_agent_1 = require("https-proxy-agent");
+const logger_1 = __importDefault(require("../logger"));
+const PluginContext_1 = require("../PluginContext");
+/**
+ * The proxy for one of Xenon's own calls to another server (a hub's to its
+ * nodes and to a cloud provider, a node's to its hub, and the rest of
+ * Xenon's internal calls), one rule whichever client makes the call:
+ *
+ * 1. None for a host `no_proxy` / `NO_PROXY` names (envProxyFor's list).
+ * 2. The `proxy` plugin option when it is set, for http and https alike,
+ *    except for a loopback host (`localhost`, 127.x, ::1): a proxy elsewhere
+ *    can't reach this machine's loopback.
+ * 3. Else the environment's proxy for the URL's scheme (envProxyFor).
+ *
+ * Through 2.15 the option reached one call, the create a hub sends to a node
+ * or a cloud provider; that session's commands, screenshots and heartbeats,
+ * device control, the sockets and a node's calls to its hub took the
+ * environment's proxy instead, or none.
+ */
+function outboundProxyFor(target, opts = {}) {
+    var _a, _b;
+    const url = toUrl(target);
+    const scheme = schemeOf(url);
+    if (!scheme)
+        return undefined;
+    const env = (_a = opts.env) !== null && _a !== void 0 ? _a : process.env;
+    if (namedByNoProxy(url, env))
+        return undefined;
+    const option = 'option' in opts ? opts.option : pluginProxyOption();
+    const configured = proxyOptionUrl(option, (_b = opts.warn) !== null && _b !== void 0 ? _b : warnOnce);
+    if (configured && !isLoopback(url.hostname))
+        return configured;
+    return schemeProxy(scheme, env);
+}
+/**
+ * The environment's proxy for a URL, by the rule axios (0.27's http adapter)
+ * applies to Xenon's axios calls:
+ * - `http_proxy` or `HTTP_PROXY` for an http URL, `https_proxy` or
+ *   `HTTPS_PROXY` for an https one, the lower-case name first (ws and wss
+ *   count as http and https);
+ * - none when `no_proxy` or `NO_PROXY` (the lower-case name first; a
+ *   comma-separated list) has `*`, the URL's host name, or a suffix of it
+ *   starting with a dot (`.lab.example`). An entry is a host name only: one
+ *   with a port matches nothing, as in axios.
+ *
+ * Through 2.15 a command forwarded to a node took HTTP_PROXY or HTTPS_PROXY
+ * whatever its scheme and ignored NO_PROXY, the live-preview and logcat
+ * sockets ignored every proxy, and so did a node fetching its hub's keys.
+ */
+function envProxyFor(target, env = process.env) {
+    const url = toUrl(target);
+    const scheme = schemeOf(url);
+    if (!scheme || namedByNoProxy(url, env))
+        return undefined;
+    return schemeProxy(scheme, env);
+}
+/**
+ * An agent sending an HTTP request for `target` through its proxy, or
+ * undefined to go straight there: the request in absolute form to the proxy
+ * for an http URL, a CONNECT tunnel for an https one.
+ */
+function proxyAgentFor(target, tls = {}) {
+    const proxy = outboundProxyFor(target);
+    if (!proxy)
+        return undefined;
+    const url = toUrl(target);
+    return url.protocol === 'https:' ? new TunnelAgent(proxy, tls) : new http_proxy_agent_1.HttpProxyAgent(proxy);
+}
+/**
+ * An agent opening a WebSocket for `target` (ws or wss) through its proxy, or
+ * undefined to go straight there. Always a CONNECT tunnel: an upgrade sent to
+ * a proxy in absolute form is not reliably passed on.
+ */
+function socketProxyAgentFor(target, tls = {}) {
+    const proxy = outboundProxyFor(target);
+    return proxy ? new TunnelAgent(proxy, tls) : undefined;
+}
+/**
+ * An axios request's proxy settings for `target`: through its proxy's agent,
+ * or none. Either way `proxy: false`, since the decision is made here, by
+ * outboundProxyFor; axios's own lookup reads the environment only. With no
+ * proxy, the caller's own agents stay.
+ */
+function axiosProxyConfig(target, tls = {}) {
+    const agent = proxyAgentFor(target, tls);
+    return agent ? { proxy: false, httpAgent: agent, httpsAgent: agent } : { proxy: false };
+}
+/**
+ * A CONNECT tunnel that checks the server behind it as the caller asked.
+ * HttpsProxyAgent's own options are for the connection to the proxy; the
+ * tunnelled TLS takes the request's, which axios doesn't fill in. So through
+ * 2.15 `tlsRejectUnauthorized` never reached a node or cloud provider that a
+ * proxy stood in front of.
+ */
+class TunnelAgent extends https_proxy_agent_1.HttpsProxyAgent {
+    constructor(proxy, targetTls) {
+        super(proxy);
+        this.targetTls = targetTls;
+    }
+    connect(req, opts) {
+        const _super = Object.create(null, {
+            connect: { get: () => super.connect }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const tls = this.targetTls.rejectUnauthorized === undefined
+                ? {}
+                : { rejectUnauthorized: this.targetTls.rejectUnauthorized };
+            return _super.connect.call(this, req, Object.assign(Object.assign({}, opts), tls));
+        });
+    }
+}
+/**
+ * The `proxy` option as a proxy URL: a string as it is (http:// added when
+ * it names no scheme), or `{ protocol, host, port, auth: { username,
+ * password } }` (protocol http by default, credentials escaped). One that
+ * names no host is no proxy, said once.
+ */
+function proxyOptionUrl(option, warn) {
+    var _a, _b;
+    if (option === undefined || option === null || option === '')
+        return undefined;
+    if (typeof option === 'string') {
+        const text = option.trim();
+        if (text === '')
+            return undefined;
+        return hasScheme(text) ? text : `http://${text}`;
+    }
+    const value = option;
+    if (typeof option !== 'object' || typeof value.host !== 'string' || value.host.trim() === '') {
+        warn(`The proxy option ${JSON.stringify(option)} names no host, so it is not used: ` +
+            "Xenon's calls to other servers take the environment's proxy, if any.");
+        return undefined;
+    }
+    const protocol = typeof value.protocol === 'string' && value.protocol !== ''
+        ? value.protocol.replace(/:$/, '')
+        : 'http';
+    const port = value.port === undefined || value.port === null ? '' : `:${value.port}`;
+    const username = (_a = value.auth) === null || _a === void 0 ? void 0 : _a.username;
+    const password = (_b = value.auth) === null || _b === void 0 ? void 0 : _b.password;
+    const credentials = typeof username === 'string' && username !== ''
+        ? `${encodeURIComponent(username)}${typeof password === 'string' ? `:${encodeURIComponent(password)}` : ''}@`
+        : '';
+    return `${protocol}://${credentials}${value.host.trim()}${port}`;
+}
+const warned = new Set();
+function warnOnce(message) {
+    if (warned.has(message))
+        return;
+    warned.add(message);
+    logger_1.default.warn(message);
+}
+function pluginProxyOption() {
+    var _a;
+    try {
+        return (_a = typedi_1.Container.get(PluginContext_1.PluginContext).pluginArgs) === null || _a === void 0 ? void 0 : _a.proxy;
+    }
+    catch (_b) {
+        return undefined;
+    }
+}
+function toUrl(target) {
+    return typeof target === 'string' ? new URL(target) : target;
+}
+function schemeOf(url) {
+    const scheme = url.protocol.replace(/:$/, '').replace(/^ws(s?)$/, 'http$1');
+    return scheme === 'http' || scheme === 'https' ? scheme : undefined;
+}
+function hostOf(url) {
+    return url.hostname.replace(/^\[(.*)\]$/, '$1');
+}
+function namedByNoProxy(url, env) {
+    const noProxy = env.no_proxy || env.NO_PROXY;
+    if (!noProxy)
+        return false;
+    const host = hostOf(url);
+    return noProxy
+        .split(',')
+        .map((entry) => entry.trim())
+        .some((entry) => entry !== '' &&
+        (entry === '*' || entry === host || (entry.startsWith('.') && host.endsWith(entry))));
+}
+function schemeProxy(scheme, env) {
+    const proxy = env[`${scheme}_proxy`] || env[`${scheme.toUpperCase()}_PROXY`];
+    if (!proxy)
+        return undefined;
+    return hasScheme(proxy) ? proxy : `http://${proxy}`;
+}
+function hasScheme(text) {
+    return /^[a-z][a-z0-9+.-]*:\/\//i.test(text);
+}
+function isLoopback(hostname) {
+    const host = hostname.replace(/^\[(.*)\]$/, '$1').toLowerCase();
+    return (host === 'localhost' ||
+        host.endsWith('.localhost') ||
+        /^127(\.\d{1,3}){3}$/.test(host) ||
+        host === '::1' ||
+        host === '0:0:0:0:0:0:0:1');
+}

package/lib/src/index.js

@@ -68,6 +68,12 @@ const cleanup = () => __awaiter(void 0, void 0, void 0, function* () {
         // Bounded so a hung driver can't hold up systemd (default 90s timeout).
         const { ShutdownCoordinator } = yield Promise.resolve().then(() => __importStar(require('./services/ShutdownCoordinator')));
         yield typedi_1.Container.get(ShutdownCoordinator).drain(15000);
+        // Telemetry next, as early as it can be: on SIGTERM Appium exits before
+        // Phase 2 (see the 'exit' hook below), and placed last it never ran. What
+        // the OTel exporters still hold is sent, and the spans of sessions still
+        // running on a node or at a cloud provider end, saying so. Lines logged
+        // after this aren't exported.
+        yield shutDownTelemetry(3000);
         const { default: IOSStreamService } = yield Promise.resolve().then(() => __importStar(require('./device-managers/ios/IOSStreamService')));
         const { default: AndroidStreamService } = yield Promise.resolve().then(() => __importStar(require('./device-managers/android/AndroidStreamService')));
         const { LogcatStreamService } = yield Promise.resolve().then(() => __importStar(require('./device-managers/android/LogcatStreamService')));
@@ -94,11 +100,26 @@ const cleanup = () => __awaiter(void 0, void 0, void 0, function* () {
         logger_1.default.error(`❌ [Xenon] Cleanup failed: ${err.message}`);
     }
     finally {
+        // When the drain threw, the telemetry wasn't shut down above. A second
+        // call does nothing.
+        yield shutDownTelemetry(1000);
         // Principal Delay: Wait 2 seconds before hard-exiting to allow
         // other async handlers (like hub unregistration) to finish.
         setTimeout(() => process.exit(0), 2000);
     }
 });
+function shutDownTelemetry(budgetMs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        try {
+            const { TracingService } = yield Promise.resolve().then(() => __importStar(require('./services/TracingService')));
+            yield typedi_1.Container.get(TracingService).shutdownWithin(budgetMs);
+        }
+        catch (err) {
+            logger_1.default.warn(`[Xenon] Telemetry shutdown failed: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+        }
+    });
+}
 process.on('SIGINT', cleanup);
 process.on('SIGTERM', cleanup);
 // Last-resort synchronous net for every long-lived sidecar.

package/lib/src/interceptors/CommandInterceptor.js

@@ -118,6 +118,7 @@ let CommandInterceptor = class CommandInterceptor {
                 return yield next();
             const sessionId = driver.sessionId || args[args.length - 1];
             const tracingService = typedi_1.Container.get(TracingService_1.TracingService);
+            const spanId = `${sessionId}:${commandName}`;
             let span;
             if (isHub && sessionId) {
                 span = tracingService.startCommandSpan(sessionId, commandName, {
@@ -130,6 +131,7 @@ let CommandInterceptor = class CommandInterceptor {
             // those services having to accept a context parameter.
             const spanCtx = span === null || span === void 0 ? void 0 : span.spanContext();
             const cmdStart = Date.now();
+            let failure;
             try {
                 return yield sessionContext_1.sessionContext.run({
                     sessionId: sessionId || undefined,
@@ -137,9 +139,16 @@ let CommandInterceptor = class CommandInterceptor {
                     commandName,
                     traceId: spanCtx === null || spanCtx === void 0 ? void 0 : spanCtx.traceId,
                     spanId: spanCtx === null || spanCtx === void 0 ? void 0 : spanCtx.spanId,
-                }, () => this.handleInContext(next, driver, commandName, args, pluginArgs, isHub, sessionId, span, tracingService));
+                }, () => this.handleInContext(next, driver, commandName, args, pluginArgs, isHub, sessionId));
+            }
+            catch (error) {
+                // What the client gets: a healed find returned an element instead.
+                failure = { error };
+                throw error;
             }
             finally {
+                if (span)
+                    tracingService.endCommandSpan(spanId, span, failure);
                 // Aggregate counter — no per-session label, just fleet-wide throughput
                 // so Prom rate() gives commands/sec and the duration sum gives avg
                 // latency. Errors still count: a 429-hit dashboard poll is still hub
@@ -148,7 +157,7 @@ let CommandInterceptor = class CommandInterceptor {
             }
         });
     }
-    handleInContext(next, driver, commandName, args, pluginArgs, isHub, sessionId, span, tracingService) {
+    handleInContext(next, driver, commandName, args, pluginArgs, isHub, sessionId) {
         return __awaiter(this, void 0, void 0, function* () {
             if (commandName === 'createSession' || commandName === 'deleteSession') {
                 try {
@@ -158,8 +167,6 @@ let CommandInterceptor = class CommandInterceptor {
                     if (commandName === 'deleteSession' && sessionId) {
                         typedi_1.Container.get(AutowaitService_1.AutowaitService).clearSession(sessionId);
                     }
-                    if (span)
-                        tracingService.endSpan(`${sessionId}:${commandName}`);
                 }
             }
             try {
@@ -181,7 +188,7 @@ let CommandInterceptor = class CommandInterceptor {
                                 scriptArgs = {};
                             }
                         }
-                        const aiCommand = script.replace(/^(xe|xenon)\s*:\s*/, '').trim();
+                        const aiCommand = (0, xenonScripts_1.interceptorScriptName)(script);
                         // appium-wait-plugin compatible alias — strip the `plugin:` prefix
                         // and map the old camelCase names so existing tests Just Work.
                         const legacyWaitCommand = script.replace(/^plugin\s*:\s*/, '').trim();
@@ -232,12 +239,7 @@ let CommandInterceptor = class CommandInterceptor {
                                     : '';
                             return yield typedi_1.Container.get(AICommandService_1.AICommandService).assertVisualState(driver, instruction);
                         }
-                        if (aiCommand === 'addMock' ||
-                            aiCommand === 'removeMock' ||
-                            aiCommand === 'clearMocks' ||
-                            aiCommand === 'getRequests' ||
-                            aiCommand === 'getMocks' ||
-                            aiCommand === 'exportHar') {
+                        if ((0, xenonScripts_1.isNetworkCaptureScript)(script)) {
                             const payload = typeof scriptArgs === 'object' && scriptArgs !== null ? scriptArgs : {};
                             const { InterceptorService } = yield Promise.resolve().then(() => __importStar(require('../services/InterceptorService')));
                             const interceptor = typedi_1.Container.get(InterceptorService);
@@ -385,10 +387,6 @@ let CommandInterceptor = class CommandInterceptor {
                 }
                 throw error;
             }
-            finally {
-                if (isHub && sessionId && span)
-                    tracingService.endSpan(`${sessionId}:${commandName}`);
-            }
         });
     }
     warnUnreadableHealingTiers(driver, sessionId, unreadable) {

package/lib/src/interceptors/xenonScripts.js

@@ -14,9 +14,26 @@
  * - A name Xenon doesn't have fails with `unknown command`.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.XENON_SCRIPT_NAMES = void 0;
+exports.XENON_SCRIPT_NAMES = exports.NETWORK_CAPTURE_SCRIPTS = void 0;
+exports.interceptorScriptName = interceptorScriptName;
+exports.isNetworkCaptureScript = isNetworkCaptureScript;
 exports.xenonScriptName = xenonScriptName;
 exports.unknownXenonScriptMessage = unknownXenonScriptMessage;
+/**
+ * The scripts CommandInterceptor answers from the session's network capture.
+ * Their arguments and answers are the capture (requests, HAR, mocks), which
+ * REST shows to admins only, so the command log keeps neither (commandLogFields).
+ * A new script that answers from the capture goes in this list. A hub hides
+ * by its own copy, so it needs the release that adds the script.
+ */
+exports.NETWORK_CAPTURE_SCRIPTS = [
+    'addMock',
+    'removeMock',
+    'clearMocks',
+    'getMocks',
+    'getRequests',
+    'exportHar',
+];
 /** The names CommandInterceptor and the session-details commands answer. Keep in step with both. */
 exports.XENON_SCRIPT_NAMES = [
     'setAutowaitProperties',
@@ -29,18 +46,22 @@ exports.XENON_SCRIPT_NAMES = [
     'analyzeScreen',
     'omniScan',
     'assertVisualState',
-    'addMock',
-    'removeMock',
-    'clearMocks',
-    'getMocks',
-    'getRequests',
-    'exportHar',
+    ...exports.NETWORK_CAPTURE_SCRIPTS,
     'setSessionName',
     'setSessionStatus',
     'debug',
     'addTag',
     'captureEvidence',
 ];
+/** The name CommandInterceptor routes a script by: its `xe:` / `xenon:` prefix, if any, taken off. */
+function interceptorScriptName(script) {
+    return script.replace(/^(xe|xenon)\s*:\s*/, '').trim();
+}
+/** Whether CommandInterceptor answers `script` from the session's network capture. */
+function isNetworkCaptureScript(script) {
+    return (typeof script === 'string' &&
+        exports.NETWORK_CAPTURE_SCRIPTS.includes(interceptorScriptName(script)));
+}
 /** The name in a `xenon: <name>` or `xe: <name>` script, or null for any other script. */
 function xenonScriptName(script) {
     if (typeof script !== 'string')

package/lib/src/logger.js

@@ -185,7 +185,9 @@ class XenonLogger {
             }
             if (redactedArgs.length)
                 logEntry.args = redactedArgs;
-            this.baseLogger.info(JSON.stringify(logEntry));
+            // At its own level, so --log-level filters it and an error reaches
+            // stderr, as in text mode.
+            this.baseLogger[level](JSON.stringify(logEntry));
         }
         else {
             const ctxPrefix = this.buildTextPrefix(ctx);

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");
@@ -112,8 +113,18 @@ class XenonPlugin extends base_plugin_1.default {
             const sessionId = driver.sessionId;
             typedi_1.Container.get(LiveSessionOwners_1.LiveSessionOwners).forget(sessionId);
             (0, sessionMemory_1.forgetSessionMemory)(sessionId);
-            if (sessionId)
+            // With the dashboard on or off: this was the only place a session span
+            // ended, and only with the dashboard on.
+            if (sessionId) {
+                typedi_1.Container.get(TracingService_1.TracingService).endSessionSpan(sessionId, {
+                    failed: true,
+                    reason: (0, shutdownReason_1.unexpectedShutdownReason)(cause),
+                });
+            }
+            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.
@@ -160,9 +171,6 @@ class XenonPlugin extends base_plugin_1.default {
                     }
                 }
                 yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStopped(sessionId, SessionStatus_1.SessionStatus.FAILED, reason);
-                typedi_1.Container.get(TracingService_1.TracingService).endSpan(sessionId, 'ERROR', {
-                    'xenon.session.stop_reason': 'Unexpected shutdown',
-                });
             }
         });
     }

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

@@ -93,9 +93,9 @@ function checkDatabase(opts) {
     }
     if (configured && configured !== client) {
         return {
-            warning: `[Database] databaseProvider is "${configured}", but this install's database client is ` +
-                `built for ${clientLabel}, so the setting has no effect. Your data is in ${where}. ` +
-                `Set databaseProvider to "${client}", or remove it.`,
+            warning: `[Database] databaseProvider is "${configured}", which has no effect: this install ` +
+                `stores its data in ${clientLabel}, in ${where}, and the database itself decides how ` +
+                `its schema is brought up to date. Remove the setting, or set it to "${client}".`,
         };
     }
     return {};