@xenon-device-management/xenon 2.9.2 → 2.10.1

package/lib/src/services/SelectorVerificationJob.js

@@ -27,6 +27,8 @@ const prisma_1 = require("../prisma");
 const SocketServer_1 = require("./SocketServer");
 const SocketEvents_1 = require("../enums/SocketEvents");
 const logger_1 = __importDefault(require("../logger"));
+const SelectorStateService_1 = require("./SelectorStateService");
+const selectorKeys_1 = require("./selector-health/selectorKeys");
 const log = logger_1.default.scope('SelectorVerification');
 /**
  * Threshold of distinct clean build_ids required to promote a Pending
@@ -50,24 +52,68 @@ let SelectorVerificationJob = class SelectorVerificationJob {
         this.socket = socket !== null && socket !== void 0 ? socket : typedi_1.Container.get(SocketServer_1.SocketServer);
     }
     /**
-     * Process every row currently in `'pending'`. Each row is wrapped in its
-     * own try/catch so a query failure on one selector can't take down the
-     * remainder of the run.
+     * Process every row currently in `'pending'`, then look for a heal of every
+     * `'resolved'` one. Each row is wrapped in its own try/catch so a query
+     * failure on one selector can't take down the remainder of the run.
      */
     run() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            var _a, _b;
             const pending = yield this.prisma.selectorState.findMany({
                 where: { status: 'pending' },
             });
             for (const row of pending) {
                 try {
-                    yield this.processOne(row);
+                    if (!(yield this.brokeAgain(row)))
+                        yield this.processOne(row);
                 }
                 catch (err) {
                     log.error(`[${row.id}] processing failed (${row.original_strategy}=${row.original_selector}): ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
                 }
             }
+            const resolved = yield this.prisma.selectorState.findMany({
+                where: { status: 'resolved' },
+            });
+            for (const row of resolved) {
+                try {
+                    yield this.brokeAgain(row);
+                }
+                catch (err) {
+                    log.error(`[${row.id}] heal check failed (${row.original_strategy}=${row.original_selector}): ${(_b = err === null || err === void 0 ? void 0 : err.message) !== null && _b !== void 0 ? _b : err}`);
+                }
+            }
+        });
+    }
+    /**
+     * A heal since the selector was marked fixed means it broke again. The heal
+     * write path says so at once (`onHealRecorded`), but that call can fail and
+     * isn't tried again, and the clean-build count below doesn't look at healed
+     * builds: a selector with three clean builds was promoted however often it
+     * healed in others. So the job checks too, and makes the same change.
+     */
+    brokeAgain(row) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!row.fixed_at)
+                return false;
+            const heal = yield this.prisma.sessionLog.findFirst({
+                where: {
+                    AND: [
+                        { is_healed: true, createdAt: { gte: row.fixed_at } },
+                        (0, selectorKeys_1.tupleWhere)(row.original_strategy, row.original_selector),
+                    ],
+                },
+                orderBy: { createdAt: 'desc' },
+                select: { session_id: true },
+            });
+            if (!heal)
+                return false;
+            log.warn(`[${row.id}] healed again after being marked fixed, unnoticed when it healed (${row.original_strategy}=${row.original_selector}, session=${heal.session_id})`);
+            yield new SelectorStateService_1.SelectorStateService(this.prisma, this.socket).onHealRecorded({
+                strategy: row.original_strategy,
+                selector: row.original_selector,
+                sessionId: heal.session_id,
+            });
+            return true;
         });
     }
     processOne(row) {
@@ -109,15 +155,19 @@ let SelectorVerificationJob = class SelectorVerificationJob {
     promoteToResolved(row) {
         return __awaiter(this, void 0, void 0, function* () {
             const now = new Date();
-            const updated = yield this.prisma.selectorState.update({
-                where: { id: row.id },
-                data: {
-                    status: 'resolved',
-                    resolved_at: now,
-                    clean_builds_count: CLEAN_BUILDS_TO_RESOLVE,
-                    last_event_at: now,
-                },
-            });
+            const updated = yield this.prisma.$transaction((tx) => __awaiter(this, void 0, void 0, function* () {
+                const promoted = yield tx.selectorState.update({
+                    where: { id: row.id },
+                    data: {
+                        status: 'resolved',
+                        resolved_at: now,
+                        clean_builds_count: CLEAN_BUILDS_TO_RESOLVE,
+                        last_event_at: now,
+                    },
+                });
+                yield tx.selectorEvent.create((0, SelectorStateService_1.selectorEventData)({ strategy: row.original_strategy, selector: row.original_selector }, 'verified'));
+                return promoted;
+            }));
             log.info(`[${row.id}] promoted to resolved (${row.original_strategy}=${row.original_selector})`);
             this.socket.emitToDashboard(SocketEvents_1.SocketEvents.SELECTOR_RESOLVED, this.serialize(updated));
         });

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

@@ -0,0 +1,94 @@
+"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.AndroidMetricsSampler = void 0;
+const androidMetrics_1 = require("./androidMetrics");
+const types_1 = require("./types");
+/**
+ * Samples an Android phone every SAMPLE_INTERVAL_MS with one `adb shell`
+ * call. The app is the session's package, else the app in the foreground.
+ * Samples never overlap: the next is scheduled when one finishes.
+ */
+class AndroidMetricsSampler {
+    constructor(opts) {
+        this.opts = opts;
+        this.stopped = false;
+        this.prev = null;
+        this.failures = 0;
+        this.foreground = null;
+        this.pkg = (0, androidMetrics_1.isSafePackage)(opts.appPackage) ? opts.appPackage : null;
+    }
+    start() {
+        this.schedule(0);
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.stopped = true;
+            if (this.timer)
+                clearTimeout(this.timer);
+        });
+    }
+    schedule(delay) {
+        var _a, _b;
+        if (this.stopped)
+            return;
+        this.timer = setTimeout(() => {
+            void this.sample().finally(() => this.schedule(types_1.SAMPLE_INTERVAL_MS));
+        }, delay);
+        (_b = (_a = this.timer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    now() {
+        return this.opts.now ? this.opts.now() : Date.now();
+    }
+    sample() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const appId = yield this.appId();
+                const reading = (0, androidMetrics_1.parseAndroidReading)(yield this.opts.shell((0, androidMetrics_1.androidSampleCommand)(appId)));
+                if (!reading)
+                    throw new Error('unreadable /proc output');
+                const sample = (0, androidMetrics_1.androidSample)(this.prev, reading, appId, this.now());
+                this.prev = reading;
+                this.failures = 0;
+                if (!this.stopped)
+                    this.opts.hooks.onSample(sample);
+            }
+            catch (err) {
+                this.failures += 1;
+                if (this.failures >= types_1.MAX_CONSECUTIVE_FAILURES && !this.stopped) {
+                    this.stopped = true;
+                    this.opts.hooks.onGiveUp((_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : String(err));
+                }
+            }
+        });
+    }
+    appId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.pkg)
+                return this.pkg;
+            const now = this.now();
+            if (this.foreground && now - this.foreground.at < types_1.FOREGROUND_REFRESH_MS) {
+                return this.foreground.pkg;
+            }
+            let pkg = null;
+            try {
+                pkg = (0, androidMetrics_1.parseForegroundPackage)(yield this.opts.shell('dumpsys activity activities'));
+            }
+            catch (_a) {
+                // Device figures still count; the app waits for the next lookup.
+            }
+            this.foreground = { pkg, at: now };
+            return pkg;
+        });
+    }
+}
+exports.AndroidMetricsSampler = AndroidMetricsSampler;

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

@@ -0,0 +1,120 @@
+"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.IOSMetricsSampler = void 0;
+const iosMetrics_1 = require("./iosMetrics");
+const types_1 = require("./types");
+/** A reading older than this is not reported again. */
+const STALE_MS = 2 * types_1.SAMPLE_INTERVAL_MS;
+/**
+ * Device CPU of an iPhone, from a long-running `ios sysmontap` through the
+ * phone's tunnel (borrowed, and asked for again so it outlives the 2-minute
+ * idle stop). Reports the latest reading every SAMPLE_INTERVAL_MS.
+ */
+class IOSMetricsSampler {
+    constructor(opts) {
+        this.opts = opts;
+        this.stopped = false;
+        this.failures = 0;
+        this.timers = [];
+    }
+    start() {
+        void this.launch();
+        this.every(types_1.SAMPLE_INTERVAL_MS, () => this.report());
+        this.every(types_1.TUNNEL_RENEW_MS, () => {
+            void this.opts.tunnels.borrow(this.opts.udid).catch(() => null);
+        });
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            this.stopped = true;
+            this.timers.forEach((t) => clearInterval(t));
+            if (this.relaunch)
+                clearTimeout(this.relaunch);
+            (_a = this.proc) === null || _a === void 0 ? void 0 : _a.kill('SIGTERM');
+            this.proc = undefined;
+        });
+    }
+    every(ms, fn) {
+        var _a;
+        const t = setInterval(fn, ms);
+        (_a = t.unref) === null || _a === void 0 ? void 0 : _a.call(t);
+        this.timers.push(t);
+    }
+    launch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (this.stopped)
+                return;
+            // Below iOS 17 there is no tunnel (null), and sysmontap needs none.
+            yield this.opts.tunnels.borrow(this.opts.udid).catch(() => null);
+            if (this.stopped)
+                return;
+            const proc = this.opts.spawnSysmontap(this.opts.tunnels.envFor(this.opts.udid));
+            this.proc = proc;
+            let rest = '';
+            const read = (chunk) => {
+                var _a;
+                const lines = (rest + chunk.toString()).split('\n');
+                rest = (_a = lines.pop()) !== null && _a !== void 0 ? _a : '';
+                for (const line of lines) {
+                    const cpu = (0, iosMetrics_1.parseSysmontapCpu)(line);
+                    if (cpu !== null) {
+                        this.latest = { cpu, at: Date.now() };
+                        this.failures = 0;
+                    }
+                }
+            };
+            (_a = proc.stdout) === null || _a === void 0 ? void 0 : _a.on('data', read);
+            (_b = proc.stderr) === null || _b === void 0 ? void 0 : _b.on('data', read);
+            let ended = false;
+            const end = () => {
+                if (ended)
+                    return;
+                ended = true;
+                this.exited(proc);
+            };
+            proc.once('exit', end);
+            proc.once('error', end);
+        });
+    }
+    exited(proc) {
+        var _a, _b;
+        if (this.proc === proc)
+            this.proc = undefined;
+        if (this.stopped)
+            return;
+        this.failures += 1;
+        if (this.failures >= types_1.MAX_CONSECUTIVE_FAILURES) {
+            void this.stop();
+            this.opts.hooks.onGiveUp('ios sysmontap kept exiting');
+            return;
+        }
+        const delay = Math.min(30000, types_1.SAMPLE_INTERVAL_MS * 2 ** (this.failures - 1));
+        this.relaunch = setTimeout(() => void this.launch(), delay);
+        (_b = (_a = this.relaunch).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    report() {
+        if (this.stopped || !this.latest || Date.now() - this.latest.at > STALE_MS)
+            return;
+        this.opts.hooks.onSample({
+            at: Date.now(),
+            deviceCpuPct: this.latest.cpu,
+            deviceMemMb: null,
+            deviceMemTotalMb: null,
+            appCpuPct: null,
+            appMemMb: null,
+            appId: null,
+        });
+    }
+}
+exports.IOSMetricsSampler = IOSMetricsSampler;

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

@@ -0,0 +1,238 @@
+"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 __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.SessionMetricsService = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../../logger"));
+const prisma_1 = require("../../prisma");
+const PluginContext_1 = require("../../PluginContext");
+const localDeviceHosts_1 = require("../../device-managers/localDeviceHosts");
+const device_managers_1 = require("../../device-managers");
+const AndroidDeviceManager_1 = __importDefault(require("../../device-managers/AndroidDeviceManager"));
+const IOSTunnels_1 = require("../../device-managers/ios/IOSTunnels");
+const goIosBinary_1 = require("../../device-managers/ios/goIosBinary");
+const ProcessRegistry_1 = require("../ProcessRegistry");
+const androidMetrics_1 = require("./androidMetrics");
+const AndroidMetricsSampler_1 = require("./AndroidMetricsSampler");
+const IOSMetricsSampler_1 = require("./IOSMetricsSampler");
+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. */
+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.
+ */
+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) {
+        var _a, _b;
+        if (!device)
+            return false;
+        const ctx = this.context();
+        if (((_a = ctx.pluginArgs) === null || _a === void 0 ? void 0 : _a.sessionMetrics) === false)
+            return false;
+        const platform = String((_b = device.platform) !== null && _b !== void 0 ? _b : '').toLowerCase();
+        // An emulator's /proc reads like a phone's; a simulator has no sysmontap.
+        if (platform !== 'android' && !(platform === 'ios' && device.realDevice === true)) {
+            return false;
+        }
+        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))
+            return;
+        const hooks = {
+            onSample: (s) => { var _a; return (_a = this.running.get(sessionId)) === null || _a === void 0 ? void 0 : _a.buffer.push(s); },
+            onGiveUp: (reason) => {
+                const entry = this.running.get(sessionId);
+                if (entry)
+                    entry.gaveUp = true;
+                this.log.warn(`[${sessionId}] Stopped sampling ${device.udid}: ${reason}`);
+            },
+        };
+        let sampler;
+        try {
+            sampler = 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);
+        this.running.set(sessionId, {
+            sampler,
+            buffer: [],
+            flushTimer,
+            writing: Promise.resolve(),
+            gaveUp: false,
+        });
+        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) {
+        const entry = this.running.get(sessionId);
+        if (!entry)
+            return 'off';
+        return entry.gaveUp ? 'stopped' : 'sampling';
+    }
+    /** Stops the session's sampler and writes what it buffered. Idempotent. */
+    stop(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entry = this.running.get(sessionId);
+            if (!entry)
+                return;
+            this.running.delete(sessionId);
+            clearInterval(entry.flushTimer);
+            yield entry.sampler.stop().catch(() => undefined);
+            yield this.write(sessionId, entry);
+        });
+    }
+    flush(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entry = this.running.get(sessionId);
+            if (entry)
+                yield this.write(sessionId, entry);
+        });
+    }
+    /** On failure the samples wait for the next write; the newest MAX_BUFFERED_SAMPLES are kept. */
+    write(sessionId, entry) {
+        entry.writing = entry.writing.then(() => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const batch = entry.buffer.splice(0);
+            if (batch.length === 0)
+                return;
+            try {
+                yield this.writeSamples(sessionId, batch);
+            }
+            catch (err) {
+                entry.buffer.unshift(...batch);
+                const over = entry.buffer.length - types_1.MAX_BUFFERED_SAMPLES;
+                if (over > 0)
+                    entry.buffer.splice(0, over);
+                this.log.debug(`[${sessionId}] Writing ${batch.length} samples failed: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+            }
+        }));
+        return entry.writing;
+    }
+    // ---------------------------------------------------------------------
+    // Seams. Overridden by tests; the defaults are the real thing.
+    // ---------------------------------------------------------------------
+    context() {
+        return typedi_1.Container.get(PluginContext_1.PluginContext);
+    }
+    writeSamples(sessionId, samples) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield prisma_1.prisma.sessionMetric.createMany({
+                data: samples.map((s) => ({
+                    session_id: sessionId,
+                    at: s.at,
+                    device_cpu_pct: s.deviceCpuPct,
+                    device_mem_mb: s.deviceMemMb,
+                    device_mem_total: s.deviceMemTotalMb,
+                    app_cpu_pct: s.appCpuPct,
+                    app_mem_mb: s.appMemMb,
+                    app_id: s.appId,
+                })),
+            });
+        });
+    }
+    samplerFor(sessionId, device, capabilities, hooks) {
+        if (String(device.platform).toLowerCase() === 'android') {
+            let adb;
+            return new AndroidMetricsSampler_1.AndroidMetricsSampler({
+                appPackage: (0, androidMetrics_1.appPackageOf)(capabilities),
+                hooks,
+                shell: (command) => __awaiter(this, void 0, void 0, function* () {
+                    if (!adb)
+                        adb = this.adbCommand(device.udid);
+                    try {
+                        const { path, base } = yield adb;
+                        return yield this.execAdb(path, [...base, 'shell', command]);
+                    }
+                    catch (err) {
+                        adb = undefined; // looked up again next time
+                        throw err;
+                    }
+                }),
+            });
+        }
+        return new IOSMetricsSampler_1.IOSMetricsSampler({
+            udid: device.udid,
+            tunnels: typedi_1.Container.get(IOSTunnels_1.IOSTunnels),
+            hooks,
+            spawnSysmontap: (env) => {
+                const proc = (0, child_process_1.spawn)((0, goIosBinary_1.goIosBinaryPath)(), ['sysmontap', '--udid', device.udid], {
+                    env,
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                });
+                typedi_1.Container.get(ProcessRegistry_1.ProcessRegistry).track({
+                    sessionId,
+                    udid: device.udid,
+                    kind: 'other',
+                    process: proc,
+                });
+                return proc;
+            },
+        });
+    }
+    /**
+     * The resolved adb, and the arguments that reach this phone: the host's,
+     * then `-s <udid>`. The shared appium-adb instance names no device (its
+     * `shell()` adds `-s` only after `setDeviceId`), so with several phones on
+     * one adb server a plain `adb shell` fails.
+     */
+    adbCommand(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const managers = yield typedi_1.Container.get(device_managers_1.XenonManager).deviceInstances();
+            const android = managers.find((m) => m instanceof AndroidDeviceManager_1.default);
+            if (!android)
+                throw new Error('no Android device manager');
+            const adb = (yield android.getAdbForDevice(udid));
+            const path = (_a = adb === null || adb === void 0 ? void 0 : adb.executable) === null || _a === void 0 ? void 0 : _a.path;
+            if (!path)
+                throw new Error(`adb executable path not resolved for ${udid}`);
+            const hostArgs = adb.adbHost && adb.adbPort ? ['-H', adb.adbHost, '-P', String(adb.adbPort)] : [];
+            return { path, base: [...hostArgs, '-s', udid] };
+        });
+    }
+    execAdb(path, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { stdout } = yield execFileAsync(path, args, { timeout: ADB_TIMEOUT_MS });
+            return stdout;
+        });
+    }
+};
+exports.SessionMetricsService = SessionMetricsService;
+exports.SessionMetricsService = SessionMetricsService = __decorate([
+    (0, typedi_1.Service)()
+], SessionMetricsService);

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

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSafePackage = isSafePackage;
+exports.appPackageOf = appPackageOf;
+exports.androidSampleCommand = androidSampleCommand;
+exports.parseAndroidReading = parseAndroidReading;
+exports.androidSample = androidSample;
+exports.parseForegroundPackage = parseForegroundPackage;
+const types_1 = require("./types");
+/**
+ * An Android package name: two or more dot-separated identifiers. A session's
+ * appPackage is client input and goes into a shell command, so nothing else
+ * is ever used.
+ */
+function isSafePackage(pkg) {
+    return typeof pkg === 'string' && /^[A-Za-z][A-Za-z0-9_]*(\.[A-Za-z][A-Za-z0-9_]*)+$/.test(pkg);
+}
+/** A session's appPackage capability, in either spelling. Not yet validated. */
+function appPackageOf(caps) {
+    var _a;
+    return (_a = caps === null || caps === void 0 ? void 0 : caps['appium:appPackage']) !== null && _a !== void 0 ? _a : caps === null || caps === void 0 ? void 0 : caps.appPackage;
+}
+/** The one shell command a sample runs: device CPU and memory, then the app's. */
+function androidSampleCommand(pkg) {
+    const device = 'head -1 /proc/stat; grep -e ^MemTotal: -e ^MemAvailable: /proc/meminfo';
+    if (pkg === null)
+        return device;
+    if (!isSafePackage(pkg))
+        throw new Error(`not a package name: ${pkg}`);
+    return (`${device}; p=$(pidof ${pkg} | cut -d' ' -f1); echo "pid=$p"; ` +
+        'if [ -n "$p" ]; then echo "stat=$(cut -d" " -f14,15 /proc/$p/stat)"; grep VmRSS /proc/$p/status; fi');
+}
+const num = (m) => (m ? Number(m[1]) : null);
+function parseAndroidReading(out) {
+    var _a;
+    const cpu = out.match(/^cpu\s+([\d\s]+)$/m);
+    if (!cpu)
+        return null;
+    const f = cpu[1].trim().split(/\s+/).map(Number);
+    if (f.length < 4 || f.some((n) => !Number.isFinite(n)))
+        return null;
+    // user nice system idle iowait irq softirq steal; guest time is already in user.
+    const cpuTotal = f.slice(0, 8).reduce((a, b) => a + b, 0);
+    const cpuIdle = f[3] + ((_a = f[4]) !== null && _a !== void 0 ? _a : 0);
+    const pid = num(out.match(/^pid=(\d+)\s*$/m));
+    const stat = out.match(/^stat=(\d+) (\d+)\s*$/m);
+    return {
+        cpuTotal,
+        cpuIdle,
+        memTotalKb: num(out.match(/^MemTotal:\s+(\d+) kB/m)),
+        memAvailableKb: num(out.match(/^MemAvailable:\s+(\d+) kB/m)),
+        pid,
+        appJiffies: pid !== null && stat ? Number(stat[1]) + Number(stat[2]) : null,
+        appRssKb: pid !== null ? num(out.match(/^VmRSS:\s+(\d+) kB/m)) : null,
+    };
+}
+const pct = (share) => (0, types_1.round1)((0, types_1.clamp)(share * 100, 0, 100));
+const mb = (kb) => (0, types_1.round1)(kb / 1024);
+/**
+ * A sample from this reading and the one before it. CPU needs both: the
+ * first sample has none, and the app's needs the same process in both, so a
+ * restarted app shows no CPU for one sample rather than a spike.
+ */
+function androidSample(prev, cur, appId, at) {
+    let deviceCpuPct = null;
+    let appCpuPct = null;
+    const dTotal = prev ? cur.cpuTotal - prev.cpuTotal : 0;
+    if (prev && dTotal > 0) {
+        deviceCpuPct = pct(1 - (cur.cpuIdle - prev.cpuIdle) / dTotal);
+        if (cur.pid !== null &&
+            cur.pid === prev.pid &&
+            cur.appJiffies !== null &&
+            prev.appJiffies !== null) {
+            appCpuPct = pct((cur.appJiffies - prev.appJiffies) / dTotal);
+        }
+    }
+    const hasApp = cur.pid !== null;
+    return {
+        at,
+        deviceCpuPct,
+        deviceMemMb: cur.memTotalKb !== null && cur.memAvailableKb !== null
+            ? mb(cur.memTotalKb - cur.memAvailableKb)
+            : null,
+        deviceMemTotalMb: cur.memTotalKb !== null ? mb(cur.memTotalKb) : null,
+        appCpuPct,
+        appMemMb: hasApp && cur.appRssKb !== null ? mb(cur.appRssKb) : null,
+        appId: hasApp ? appId : null,
+    };
+}
+/** The foreground app from `dumpsys activity activities`, before and after Android 10. */
+function parseForegroundPackage(dumpsys) {
+    const m = dumpsys.match(/(?:topResumedActivity|mResumedActivity)[:=]\s*ActivityRecord\{\S+ u\d+ ([^\s/]+)\//);
+    return m && isSafePackage(m[1]) ? m[1] : null;
+}