@xenon-device-management/xenon 2.9.2 → 2.10.0

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;
+}

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSysmontapCpu = parseSysmontapCpu;
+const types_1 = require("./types");
+/**
+ * Device CPU % from one line of `ios sysmontap`, or null for any other line.
+ * go-ios logs JSON lines; a reading is {"msg":"received CPU usage data",
+ * "enabled_cpus":6,"cpu_total_load":77.5,...}. The load is summed over the
+ * cores (an idle 6-core iPhone 14 Plus read 77 to 125), so it is divided by
+ * them.
+ */
+function parseSysmontapCpu(line) {
+    var _a;
+    let o;
+    try {
+        o = JSON.parse(line);
+    }
+    catch (_b) {
+        return null;
+    }
+    if (!o || typeof o.cpu_total_load !== 'number' || !Number.isFinite(o.cpu_total_load)) {
+        return null;
+    }
+    const cores = (_a = [o.enabled_cpus, o.cpu_count].find((n) => typeof n === 'number' && n > 0)) !== null && _a !== void 0 ? _a : 1;
+    return (0, types_1.round1)((0, types_1.clamp)(o.cpu_total_load / cores, 0, 100));
+}

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seriesFor = seriesFor;
+exports.sessionMetricsBody = sessionMetricsBody;
+const types_1 = require("./types");
+/** What a session on this platform can have: Android everything, an iPhone device CPU. */
+function seriesFor(platform) {
+    const p = platform.toLowerCase();
+    const android = p === 'android';
+    return {
+        deviceCpu: android || p === 'ios',
+        deviceMem: android,
+        appCpu: android,
+        appMem: android,
+    };
+}
+function sessionMetricsBody(platform, rows, recording = null) {
+    var _a;
+    const sorted = [...rows].sort((a, b) => a.at - b.at);
+    const lastApp = [...sorted].reverse().find((r) => r.app_id);
+    return {
+        platform: platform.toLowerCase(),
+        intervalMs: types_1.SAMPLE_INTERVAL_MS,
+        appId: (_a = lastApp === null || lastApp === void 0 ? void 0 : lastApp.app_id) !== null && _a !== void 0 ? _a : null,
+        series: seriesFor(platform),
+        recording,
+        samples: sorted.map((r) => ({
+            t: r.at,
+            deviceCpu: r.device_cpu_pct,
+            deviceMemMb: r.device_mem_mb,
+            deviceMemTotalMb: r.device_mem_total,
+            appCpu: r.app_cpu_pct,
+            appMemMb: r.app_mem_mb,
+            app: r.app_id,
+        })),
+    };
+}

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clamp = exports.round1 = exports.MAX_BUFFERED_SAMPLES = exports.TUNNEL_RENEW_MS = exports.FOREGROUND_REFRESH_MS = exports.MAX_CONSECUTIVE_FAILURES = exports.FLUSH_INTERVAL_MS = exports.SAMPLE_INTERVAL_MS = void 0;
+/** How often a session's phone is sampled. */
+exports.SAMPLE_INTERVAL_MS = 2000;
+/** How often a session's samples are written; a crash loses at most this much. */
+exports.FLUSH_INTERVAL_MS = 10000;
+/** A sampler that fails this many times in a row stops for its session. */
+exports.MAX_CONSECUTIVE_FAILURES = 5;
+/** How long a looked-up foreground app is trusted (Android, no appPackage). */
+exports.FOREGROUND_REFRESH_MS = 10000;
+/** How often an iPhone sampler asks for its phone's tunnel again. */
+exports.TUNNEL_RENEW_MS = 30000;
+/** Samples waiting for a write that keeps failing: the newest 30 minutes. */
+exports.MAX_BUFFERED_SAMPLES = 900;
+const round1 = (n) => Math.round(n * 10) / 10;
+exports.round1 = round1;
+const clamp = (n, lo, hi) => Math.min(hi, Math.max(lo, n));
+exports.clamp = clamp;