@vpalmisano/webrtcperf 4.0.0

package/build/src/session.js

@@ -0,0 +1,1552 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Session = void 0;
+const throttler_1 = require("@vpalmisano/throttler");
+const assert_1 = __importDefault(require("assert"));
+const axios_1 = __importDefault(require("axios"));
+const chalk_1 = __importDefault(require("chalk"));
+const events_1 = __importDefault(require("events"));
+const fs_1 = __importDefault(require("fs"));
+const json5_1 = __importDefault(require("json5"));
+const lorem_ipsum_1 = require("lorem-ipsum");
+const node_cache_1 = __importDefault(require("node-cache"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const puppeteer_core_1 = __importDefault(require("puppeteer-core"));
+const puppeteer_intercept_and_modify_requests_1 = require("puppeteer-intercept-and-modify-requests");
+const sdpTransform = __importStar(require("sdp-transform"));
+const zlib_1 = require("zlib");
+const rtcstats_1 = require("./rtcstats");
+const stats_1 = require("./stats");
+const utils_1 = require("./utils");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const NavigatorHardwareConcurrency = require('puppeteer-extra-plugin-stealth/evasions/navigator.hardwareConcurrency');
+const log = (0, utils_1.logger)('webrtcperf:session');
+const PageLogColors = {
+    error: 'red',
+    warn: 'yellow',
+    info: 'cyan',
+    log: 'grey',
+    debug: 'white',
+    requestfailed: 'magenta',
+};
+/**
+ * Implements a test session instance running on a browser instance.
+ */
+class Session extends events_1.default {
+    chromiumUrl;
+    chromiumPath;
+    chromiumFieldTrials;
+    windowWidth;
+    windowHeight;
+    deviceScaleFactor;
+    display;
+    /* private readonly audioRedForOpus: boolean */
+    mediaPath;
+    videoWidth;
+    videoHeight;
+    videoFramerate;
+    useFakeMedia;
+    enableGpu;
+    enableBrowserLogging;
+    startTimestamp;
+    sessions;
+    tabsPerSession;
+    spawnPeriod;
+    statsInterval;
+    disabledVideoCodecs;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    localStorage;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    sessionStorage;
+    clearCookies;
+    scriptPath;
+    showPageLog;
+    pageLogFilter;
+    pageLogPath;
+    userAgent;
+    evaluateAfter;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    exposedFunctions;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    scriptParams;
+    blockedUrls;
+    extraHeaders;
+    responseModifiers = {};
+    downloadResponses = [];
+    extraCSS;
+    cookies = [];
+    overridePermissions = [];
+    hardwareConcurrency;
+    debuggingPort;
+    debuggingAddress;
+    randomAudioPeriod;
+    maxVideoDecoders;
+    maxVideoDecodersAt;
+    incognito;
+    serverPort;
+    serverSecret;
+    serverUseHttps;
+    running = false;
+    browser;
+    context;
+    stopPortForwarder;
+    /** The numeric id assigned to the session. */
+    id;
+    /** The throttle configuration index assigned to the session. */
+    throttleIndex;
+    /** The test page url. */
+    url;
+    /** The url query. */
+    urlQuery;
+    /**
+     * The custom URL handler. This is the path to a JavaScript module (.mjs) exporting the function.
+     * The function itself takes an object as input with the following parameters:
+     *
+     * @typedef {Object} CustomUrlHandler
+     * @property {string} id - The identifier for the URL.
+     * @property {string} sessions - The number of sessions.
+     * @property {string} tabIndex - The index of the current tab.
+     * @property {string} tabsPerSession - The number of tabs per session.
+     * @property {string} index - The index for the URL.
+     * @property {string} pid - The process identifier for the URL.
+     *
+     * @type {string} path - The path to the JavaScript file containing the function:
+     *   (params: CustomUrlHandler) => Promise<string>
+     */
+    customUrlHandler;
+    /**
+     * Imported custom URL handler function.
+     * @typedef {Object} CustomUrlHandler
+     * @property {number} id - The identifier for the URL.
+     * @property {number} sessions - The number of sessions.
+     * @property {number} tabIndex - The index of the current tab.
+     * @property {number} tabsPerSession - The number of tabs per session.
+     * @property {number} index - The index for the URL.
+     * @property {number} pid - The process identifier for the URL.
+     * @property {Record<string, string>} env - The process environment.
+     *
+     * @type {string} path - The path to the JavaScript file containing the function:
+     *   (params: CustomUrlHandler) => Promise<string>
+     */
+    customUrlHandlerFn;
+    /** The latest stats extracted from page. */
+    stats = {};
+    /** The browser opened pages. */
+    pages = new Map();
+    httpResourcesStats = new Map();
+    /** The browser opened pages metrics. */
+    pagesMetrics = new Map();
+    /** The page warnings count. */
+    pageWarnings = 0;
+    /** The page errors count. */
+    pageErrors = 0;
+    screensharePage;
+    static jsonFetchCache = new node_cache_1.default({
+        stdTTL: 30,
+        checkperiod: 15,
+    });
+    constructor({ chromiumUrl, chromiumPath, chromiumFieldTrials, windowWidth, windowHeight, deviceScaleFactor, display, 
+    /* audioRedForOpus, */
+    url, urlQuery, customUrlHandler, customUrlHandlerFn, mediaPath, videoWidth, videoHeight, videoFramerate, useFakeMedia, enableGpu, enableBrowserLogging, startTimestamp, sessions, tabsPerSession, spawnPeriod, statsInterval, disabledVideoCodecs, localStorage, sessionStorage, clearCookies, scriptPath, showPageLog, pageLogFilter, pageLogPath, userAgent, id, throttleIndex, evaluateAfter, exposedFunctions, scriptParams, blockedUrls, extraHeaders, responseModifiers, downloadResponses, extraCSS, cookies, overridePermissions, hardwareConcurrency, debuggingPort, debuggingAddress, randomAudioPeriod, maxVideoDecoders, maxVideoDecodersAt, incognito, serverPort, serverSecret, serverUseHttps, }) {
+        super();
+        log.debug('constructor', { id });
+        this.id = id;
+        this.chromiumUrl = chromiumUrl;
+        this.chromiumPath = chromiumPath || undefined;
+        this.chromiumFieldTrials = chromiumFieldTrials || undefined;
+        this.windowWidth = windowWidth || 1920;
+        this.windowHeight = windowHeight || 1080;
+        this.deviceScaleFactor = deviceScaleFactor || 1;
+        this.debuggingPort = debuggingPort || 0;
+        this.debuggingAddress = debuggingAddress || '';
+        this.display = display;
+        /* this.audioRedForOpus = !!audioRedForOpus */
+        this.url = url;
+        this.urlQuery = urlQuery;
+        if (!this.urlQuery && url.includes('?')) {
+            const parts = url.split('?', 2);
+            this.url = parts[0];
+            this.urlQuery = parts[1];
+        }
+        this.customUrlHandler = customUrlHandler;
+        this.customUrlHandlerFn = customUrlHandlerFn;
+        this.mediaPath = mediaPath;
+        this.videoWidth = videoWidth;
+        this.videoHeight = videoHeight;
+        this.videoFramerate = videoFramerate;
+        this.useFakeMedia = useFakeMedia;
+        this.enableGpu = enableGpu;
+        this.enableBrowserLogging = (0, utils_1.enabledForSession)(this.id, enableBrowserLogging);
+        this.startTimestamp = startTimestamp || Date.now();
+        this.sessions = sessions || 1;
+        this.tabsPerSession = tabsPerSession || 1;
+        (0, assert_1.default)(this.tabsPerSession >= 1, 'tabsPerSession should be >= 1');
+        this.spawnPeriod = spawnPeriod || 1000;
+        this.statsInterval = statsInterval || 10;
+        if (disabledVideoCodecs) {
+            this.disabledVideoCodecs = disabledVideoCodecs
+                .split(',')
+                .map(s => s.trim())
+                .filter(s => s.length);
+        }
+        else {
+            this.disabledVideoCodecs = [];
+        }
+        if (localStorage) {
+            try {
+                this.localStorage = json5_1.default.parse(localStorage);
+            }
+            catch (err) {
+                log.error(`error parsing localStorage: ${err.stack}`);
+                this.localStorage = null;
+            }
+        }
+        if (sessionStorage) {
+            try {
+                this.sessionStorage = json5_1.default.parse(sessionStorage);
+            }
+            catch (err) {
+                log.error(`error parsing sessionStorage: ${err.stack}`);
+                this.sessionStorage = null;
+            }
+        }
+        this.clearCookies = clearCookies;
+        this.scriptPath = scriptPath;
+        this.showPageLog = showPageLog;
+        this.pageLogFilter = pageLogFilter;
+        this.pageLogPath = pageLogPath;
+        this.userAgent = userAgent;
+        this.randomAudioPeriod = randomAudioPeriod;
+        this.maxVideoDecoders = maxVideoDecoders;
+        this.maxVideoDecodersAt = maxVideoDecodersAt;
+        this.incognito = incognito;
+        this.serverPort = serverPort;
+        this.serverSecret = serverSecret;
+        this.serverUseHttps = serverUseHttps;
+        this.throttleIndex = throttleIndex;
+        this.evaluateAfter = evaluateAfter || [];
+        this.exposedFunctions = exposedFunctions || {};
+        if (scriptParams) {
+            try {
+                this.scriptParams = json5_1.default.parse(scriptParams);
+            }
+            catch (err) {
+                log.error(`error parsing scriptParams '${scriptParams}': ${err.stack}`);
+                throw err;
+            }
+        }
+        else {
+            this.scriptParams = {};
+        }
+        this.blockedUrls = (blockedUrls || '')
+            .split(',')
+            .map(s => s.trim())
+            .filter(s => s.length);
+        // Always block sentry.io.
+        this.blockedUrls.push('ingest.sentry.io');
+        if (extraHeaders) {
+            try {
+                this.extraHeaders = json5_1.default.parse(extraHeaders);
+            }
+            catch (err) {
+                log.error(`error parsing extraHeaders: ${err.stack}`);
+                this.extraHeaders = undefined;
+            }
+        }
+        else {
+            this.extraHeaders = undefined;
+        }
+        if (responseModifiers) {
+            try {
+                const parsed = json5_1.default.parse(responseModifiers);
+                Object.entries(parsed).forEach(([url, replacements]) => {
+                    if (!Array.isArray(replacements)) {
+                        throw new Error(`responseModifiers replacements should be an array of { search, replace, body, headers } objects: ${replacements}`);
+                    }
+                    this.responseModifiers[url] = replacements.map(({ search, replace, file, headers }) => ({
+                        search: search ? new RegExp(search, 'g') : undefined,
+                        replace,
+                        file,
+                        headers,
+                    }));
+                });
+            }
+            catch (err) {
+                throw new Error(`error parsing responseModifiers "${responseModifiers}": ${err.stack}`);
+            }
+        }
+        if (downloadResponses) {
+            try {
+                const parsed = json5_1.default.parse(downloadResponses);
+                if (!Array.isArray(parsed))
+                    throw new Error(`downloadResponses should be an array: ${downloadResponses}`);
+                parsed.forEach(({ urlPattern, output, append }) => {
+                    this.downloadResponses.push({ urlPattern: (0, puppeteer_intercept_and_modify_requests_1.getUrlPatternRegExp)(urlPattern), output, append });
+                });
+            }
+            catch (err) {
+                throw new Error(`error parsing downloadResponses "${downloadResponses}": ${err.stack}`);
+            }
+        }
+        this.extraCSS = extraCSS;
+        if (cookies) {
+            try {
+                this.cookies = json5_1.default.parse(cookies);
+            }
+            catch (err) {
+                log.error(`error parsing cookies: ${err.stack}`);
+            }
+        }
+        if (overridePermissions) {
+            this.overridePermissions = overridePermissions
+                .split(',')
+                .map(s => s.trim())
+                .filter(s => s.length);
+        }
+        this.hardwareConcurrency = hardwareConcurrency;
+    }
+    /**
+     * Returns the chromium browser launch args
+     * @return the args list
+     */
+    getBrowserArgs(env) {
+        // https://peter.sh/experiments/chromium-command-line-switches/
+        // https://source.chromium.org/chromium/chromium/src/+/main:testing/variations/fieldtrial_testing_config.json;l=8877?q=%20fieldtrial_testing_config.json&ss=chromium
+        const args = [
+            '--no-sandbox',
+            '--no-zygote',
+            '--ignore-certificate-errors',
+            '--no-user-gesture-required',
+            '--autoplay-policy=no-user-gesture-required',
+            '--disable-infobars',
+            '--allow-running-insecure-content',
+            `--unsafely-treat-insecure-origin-as-secure=http://${new URL(this.url || 'http://localhost').host}`,
+            '--disable-web-security',
+            '--disable-features=IsolateOrigins,Translate,CalculateNativeWinOcclusion',
+            '--disable-background-timer-throttling',
+            '--disable-backgrounding-occluded-windows',
+            '--disable-renderer-backgrounding',
+            '--disable-site-isolation-trials',
+            '--enable-usermedia-screen-capturing',
+            '--allow-http-screen-capture',
+            `--remote-debugging-port=${this.debuggingPort ? this.debuggingPort + this.id : 0}`,
+            '--enable-features=VaapiVideoDecoder,VaapiVideoEncoder,VaapiVideoDecodeLinuxGL,ElementCapture',
+            `--window-size=${this.windowWidth},${this.windowHeight}`,
+        ];
+        let fieldTrials = this.chromiumFieldTrials || '';
+        if (this.enableBrowserLogging && this.pageLogPath) {
+            const pageLogDir = path_1.default.dirname(this.pageLogPath);
+            const eventLogPath = path_1.default.resolve(pageLogDir, `webrtc-event-logging-${this.id}`);
+            fs_1.default.mkdirSync(eventLogPath, { recursive: true });
+            args.push('--enable-logging', '--vmodule=*/webrtc/*=5', '--v=0', `--webrtc-event-logging=${eventLogPath}`);
+            fieldTrials = 'WebRTC-RtcEventLogNewFormat/Disabled/' + fieldTrials;
+            env.CHROME_LOG_FILE = path_1.default.resolve(pageLogDir, `chrome-${this.id}.log`);
+        }
+        if (this.maxVideoDecoders !== -1 && this.id >= this.maxVideoDecodersAt) {
+            fieldTrials = `WebRTC-MaxVideoDecoders/${this.maxVideoDecoders}/` + fieldTrials;
+        }
+        if (fieldTrials.length) {
+            args.push(`--force-fieldtrials=${fieldTrials}`);
+        }
+        if (this.mediaPath) {
+            if (this.useFakeMedia) {
+                log.debug(`${this.id} using chromium as fake media source`);
+                args.push('--use-fake-ui-for-media-stream', `--use-fake-device-for-media-stream=display-media-type=browser,fps=30`, `--use-file-for-fake-video-capture=${this.mediaPath.video}`, `--use-file-for-fake-audio-capture=${this.mediaPath.audio}`);
+            }
+            else {
+                log.debug(`${this.id} using ${this.mediaPath} as fake media source`);
+                args.push('--auto-accept-camera-and-microphone-capture', `--auto-select-tab-capture-source-by-title=webrtcperf-screenshare`, '--mute-audio');
+            }
+        }
+        if (this.enableGpu) {
+            args.push('--ignore-gpu-blocklist', '--enable-gpu-rasterization', '--enable-zero-copy', '--disable-gpu-sandbox', '--enable-vulkan');
+            if (this.enableGpu === 'egl') {
+                args.push('--use-gl=egl');
+            }
+            else {
+                args.push('--use-gl=angle', '--use-angle=vulkan');
+            }
+        }
+        else {
+            args.push(
+            // Disables webgl support.
+            '--disable-3d-apis', '--disable-site-isolation-trials');
+        }
+        return args;
+    }
+    /**
+     * Start
+     */
+    async start() {
+        if (this.running) {
+            return;
+        }
+        this.running = true;
+        if (this.browser) {
+            log.warn(`${this.id} start: already running`);
+            return;
+        }
+        log.debug(`${this.id} start`);
+        if (this.chromiumUrl) {
+            // connect to a remote chrome instance
+            try {
+                this.browser = await puppeteer_core_1.default.connect({
+                    browserURL: this.chromiumUrl,
+                    defaultViewport: {
+                        width: this.windowWidth,
+                        height: this.windowHeight,
+                        deviceScaleFactor: this.deviceScaleFactor,
+                        isMobile: false,
+                        hasTouch: false,
+                        isLandscape: false,
+                    },
+                });
+            }
+            catch (err) {
+                log.error(`${this.id} browser connect error: ${err.stack}`);
+                return this.stop();
+            }
+        }
+        else {
+            // run a browser instance locally
+            let executablePath = this.chromiumPath;
+            if (!executablePath || !fs_1.default.existsSync(executablePath)) {
+                executablePath = await (0, utils_1.checkChromeExecutable)();
+                log.debug(`using executablePath=${executablePath}`);
+            }
+            // Create the process wrapper.
+            if (this.throttleIndex > -1 && os_1.default.platform() === 'linux') {
+                executablePath = await (0, throttler_1.throttleLauncher)(executablePath, this.throttleIndex);
+            }
+            const env = { ...process.env };
+            if (!this.display) {
+                delete env.DISPLAY;
+            }
+            else {
+                env.DISPLAY = this.display;
+            }
+            const args = this.getBrowserArgs(env);
+            const ignoreDefaultArgs = [
+                '--disable-dev-shm-usage',
+                '--remote-debugging-port',
+                //'--hide-scrollbars',
+                '--enable-automation',
+                '--window-size',
+            ];
+            log.debug(`[session ${this.id}] Using args:\n  ${args.join('\n  ')}`);
+            log.debug(`[session ${this.id}] Default args:\n  ${puppeteer_core_1.default.defaultArgs().join('\n  ')}`);
+            try {
+                this.browser = await puppeteer_core_1.default.launch({
+                    browser: 'chrome',
+                    headless: this.display ? false : true,
+                    executablePath,
+                    handleSIGINT: false,
+                    env,
+                    // dumpio: this.enableBrowserLogging,
+                    // devtools: true,
+                    defaultViewport: {
+                        width: this.windowWidth,
+                        height: this.windowHeight,
+                        deviceScaleFactor: this.deviceScaleFactor,
+                        isMobile: false,
+                        hasTouch: false,
+                        isLandscape: false,
+                    },
+                    ignoreDefaultArgs,
+                    args,
+                });
+                const version = await this.browser.version();
+                log.debug(`[session ${this.id}] Using chrome version: ${version}`);
+            }
+            catch (err) {
+                log.error(`[session ${this.id}] Browser launch error: ${err.stack}`);
+                return this.stop();
+            }
+        }
+        (0, assert_1.default)(this.browser, 'BrowserNotCreated');
+        if (this.debuggingPort && this.debuggingAddress !== '127.0.0.1') {
+            this.stopPortForwarder = await (0, utils_1.portForwarder)(this.debuggingPort + this.id, this.debuggingAddress);
+        }
+        this.browser.once('disconnected', () => {
+            log.debug('browser disconnected');
+            return this.stop();
+        });
+        // get GPU infos from chrome://gpu page
+        /* if (this.enableGpu) {
+          try {
+            const page = await this.browser.newPage()
+            await page.goto('chrome://gpu')
+            const data = await page.evaluate(() =>
+              [
+                // eslint-disable-next-line no-undef
+                ...document.querySelectorAll('ul.feature-status-list > li > span'),
+              ].map(
+                (e, i) =>
+                  `${i % 2 === 0 ? '\n- ' : ''}${(e as HTMLSpanElement).innerText}`,
+              ),
+            )
+            await page.close()
+            console.log(`GPU infos:${data.join('')}`)
+          } catch (err) {
+            log.warn(`${this.id} error getting gpu info: %j`, err)
+          }
+        } */
+        // open pages
+        for (let i = 0; i < this.tabsPerSession; i++) {
+            this.openPage(i).catch(err => log.error(`openPage error: ${err.stack}`));
+            if (i < this.tabsPerSession - 1) {
+                await (0, utils_1.sleep)(this.spawnPeriod);
+            }
+        }
+    }
+    setupPageCmd(index, tabIndex, url) {
+        let cmd = `\
+webrtcperf = {};
+webrtcperf.config = {
+  START_TIMESTAMP: ${this.startTimestamp},
+  WEBRTC_PERF_URL: "${(0, utils_1.hideAuth)(url)}",
+  WEBRTC_PERF_SESSION: ${this.id},
+  WEBRTC_PERF_TAB_INDEX: ${tabIndex},
+  WEBRTC_PERF_INDEX: ${index},
+  STATS_INTERVAL: ${this.statsInterval},
+  VIDEO_WIDTH: ${this.videoWidth},
+  VIDEO_HEIGHT: ${this.videoHeight},
+  VIDEO_FRAMERATE: ${this.videoFramerate},
+  RANDOM_AUDIO_PERIOD: ${this.randomAudioPeriod},
+  USE_FAKE_MEDIA: ${this.useFakeMedia},
+};
+try {
+  webrtcperf.params = JSON.parse('${JSON.stringify(this.scriptParams)}' || '{}');
+} catch (err) {
+  console.error('[webrtcperf] Error parsing scriptParams:', err);
+  webrtcperf.params = {};
+}
+  `;
+        if (this.serverPort) {
+            cmd += `\
+webrtcperf.config.SAVE_MEDIA_URL = "ws${this.serverUseHttps ? 's' : ''}://localhost:${this.serverPort}/?auth=${this.serverSecret}&action=write-stream";
+    `;
+            if (this.mediaPath?.mp4 && !this.useFakeMedia) {
+                cmd += `\
+webrtcperf.config.VIDEO_URL = "http${this.serverUseHttps ? 's' : ''}://localhost:${this.serverPort}/cache/${path_1.default.basename(this.mediaPath.mp4)}?auth=${this.serverSecret}";
+webrtcperf.config.AUDIO_URL = "http${this.serverUseHttps ? 's' : ''}://localhost:${this.serverPort}/cache/${path_1.default.basename(this.mediaPath.m4a)}?auth=${this.serverSecret}";
+    `;
+            }
+        }
+        if (this.disabledVideoCodecs.length) {
+            log.debug('Using disabledVideoCodecs:', this.disabledVideoCodecs);
+            cmd += `webrtcperf.config.GET_CAPABILITIES_DISABLED_VIDEO_CODECS = JSON.parse('${JSON.stringify(this.disabledVideoCodecs)}');\n`;
+        }
+        return cmd;
+    }
+    /**
+     * openPage
+     * @param tabIndex
+     */
+    async openPage(tabIndex) {
+        if (!this.browser) {
+            return;
+        }
+        const index = this.id + tabIndex;
+        let saveFile = undefined;
+        let url = this.url;
+        if (!url) {
+            if (this.customUrlHandler && !this.customUrlHandlerFn) {
+                const customUrlHandlerPath = path_1.default.resolve(process.cwd(), this.customUrlHandler);
+                if (!fs_1.default.existsSync(customUrlHandlerPath)) {
+                    throw new Error(`Custom url handler script not found: "${customUrlHandlerPath}"`);
+                }
+                this.customUrlHandlerFn = (await import(/* webpackIgnore: true */ customUrlHandlerPath)).default;
+            }
+            if (!this.customUrlHandlerFn) {
+                throw new Error(`Custom url handler function not set`);
+            }
+            url = await this.customUrlHandlerFn({
+                id: this.id,
+                sessions: this.sessions,
+                tabIndex,
+                tabsPerSession: this.tabsPerSession,
+                index,
+                pid: process.pid,
+                env: { ...process.env },
+                params: this.scriptParams,
+            });
+            log.debug(`customUrlHandlerFn: ${url}`);
+        }
+        if (!url) {
+            throw new Error(`Page URL not set`);
+        }
+        if (this.urlQuery) {
+            url += `?${this.urlQuery
+                .replace(/\$s/g, String(this.id))
+                .replace(/\$S/g, String(this.sessions))
+                .replace(/\$t/g, String(tabIndex))
+                .replace(/\$T/g, String(this.tabsPerSession))
+                .replace(/\$i/g, String(index))
+                .replace(/\$p/g, String(process.pid))}`;
+        }
+        log.debug(`opening page ${index} (session: ${this.id} tab: ${tabIndex}): ${(0, utils_1.hideAuth)(url)}`);
+        if (this.incognito) {
+            this.context = await this.browser.createBrowserContext();
+        }
+        else {
+            this.context = this.browser.defaultBrowserContext();
+        }
+        if (this.overridePermissions.length) {
+            await this.context.overridePermissions(new URL(url).origin, this.overridePermissions);
+        }
+        const page = await this.getNewPage(tabIndex);
+        await page.setBypassCSP(true);
+        if (this.userAgent) {
+            await page.setUserAgent(this.userAgent);
+        }
+        await Promise.all(Object.keys(this.exposedFunctions).map(async (name) => await page.exposeFunction(name, (...args) => this.exposedFunctions[name](...args))));
+        // Export config to page.
+        let cmd = this.setupPageCmd(index, tabIndex, url);
+        if (this.localStorage) {
+            log.debug('Using localStorage:', this.localStorage);
+            Object.entries(this.localStorage).map(([key, value]) => {
+                cmd += `localStorage.setItem('${key}', '${JSON.stringify(value)}');\n`;
+            });
+        }
+        if (this.sessionStorage) {
+            log.debug('Using sessionStorage:', this.sessionStorage);
+            Object.entries(this.sessionStorage).map(([key, value]) => {
+                cmd += `sessionStorage.setItem('${key}', '${JSON.stringify(value)}');\n`;
+            });
+        }
+        log.debug('init command:', cmd);
+        await page.evaluateOnNewDocument(cmd);
+        // Clear cookies.
+        if (this.clearCookies) {
+            try {
+                const client = await page.target().createCDPSession();
+                await client.send('Network.clearBrowserCookies');
+            }
+            catch (err) {
+                log.error(`clearCookies error: ${err.stack}`);
+            }
+        }
+        // Load page script.
+        {
+            const filePath = (0, utils_1.resolvePackagePath)('@vpalmisano/webrtcperf-js');
+            if (!fs_1.default.existsSync(filePath)) {
+                throw new Error(`@vpalmisano/webrtcperf-js script not found: ${filePath}`);
+            }
+            log.debug(`loading @vpalmisano/webrtcperf-js script from: ${filePath}`);
+            await page.evaluateOnNewDocument(fs_1.default.readFileSync(filePath, 'utf8'));
+        }
+        // Execute external script(s).
+        if (this.scriptPath) {
+            if (this.scriptPath.startsWith('base64:gzip:')) {
+                const data = Buffer.from(this.scriptPath.replace('base64:gzip:', ''), 'base64');
+                const code = (0, zlib_1.gunzipSync)(data).toString();
+                log.debug(`loading script from ${code.length} bytes`);
+                await page.evaluateOnNewDocument(code);
+            }
+            else {
+                for (const filePath of this.scriptPath.split(',')) {
+                    if (!filePath.trim()) {
+                        continue;
+                    }
+                    if (filePath.startsWith('http')) {
+                        log.debug(`loading custom script from url: ${filePath}`);
+                        const res = await (0, utils_1.downloadUrl)(filePath);
+                        if (!res?.data) {
+                            throw new Error(`Failed to download script from: ${filePath}`);
+                        }
+                        await page.evaluateOnNewDocument(res.data);
+                    }
+                    else {
+                        if (!fs_1.default.existsSync(filePath)) {
+                            log.warn(`custom script not found: ${filePath}`);
+                            continue;
+                        }
+                        log.debug(`loading custom script from file: ${filePath}`);
+                        await page.evaluateOnNewDocument(fs_1.default.readFileSync(filePath, 'utf8'));
+                    }
+                }
+            }
+        }
+        page.on('dialog', async (dialog) => {
+            log.debug(`page ${index + 1} dialog ${dialog.type()}: ${dialog.message()}`);
+            try {
+                await dialog.accept();
+            }
+            catch (err) {
+                log.debug(`dialog accept error: ${err.message}`);
+            }
+            try {
+                await dialog.dismiss();
+            }
+            catch (err) {
+                log.debug(`dialog dismiss error: ${err.message}`);
+            }
+        });
+        page.once('close', () => {
+            log.debug(`page ${index + 1} closed`);
+            this.pages.delete(index);
+            this.httpResourcesStats.delete(index);
+            this.pagesMetrics.delete(index);
+            if (saveFile) {
+                saveFile.close().catch(err => {
+                    log.error(`saveFile close error: ${err.stack}`);
+                });
+                saveFile = undefined;
+            }
+            if (this.browser && this.running) {
+                setTimeout(() => this.openPage(index).catch(err => log.error(`openPage after close error: ${err.stack}`)), 1000);
+            }
+        });
+        // Enable request interception.
+        let setRequestInterceptionState = true;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const pageCDPSession = page._client();
+        await pageCDPSession.send('Network.setBypassServiceWorker', {
+            bypass: true,
+        });
+        const interceptManager = new puppeteer_intercept_and_modify_requests_1.RequestInterceptionManager(pageCDPSession, {
+            onError: error => {
+                log.error('Request interception error:', error);
+            },
+        });
+        const interceptions = [];
+        // Blocked URLs.
+        this.blockedUrls.forEach(blockedUrl => {
+            interceptions.push({
+                urlPattern: blockedUrl,
+                modifyRequest: () => ({ errorReason: 'BlockedByClient' }),
+            });
+        });
+        // Add extra headers.
+        if (this.extraHeaders) {
+            Object.entries(this.extraHeaders).forEach(([url, obj]) => {
+                const headers = Object.entries(obj).map(([name, value]) => ({
+                    name,
+                    value,
+                }));
+                interceptions.push({
+                    urlPattern: url,
+                    modifyRequest: ({ event }) => {
+                        log.debug(`adding extraHeaders in: ${event.request.url}`, headers);
+                        return { headers };
+                    },
+                });
+            });
+        }
+        // Response modifiers.
+        Object.entries(this.responseModifiers).forEach(([url, replacements]) => {
+            interceptions.push({
+                urlPattern: url,
+                modifyResponse: async ({ event, body }) => {
+                    const responseHeaders = event.responseHeaders || [];
+                    for (const { search, replace, file, headers } of replacements) {
+                        if (search && replace) {
+                            log.debug(`using responseModifiers in: ${event.request.url}: ${search.toString()} => ${replace}`);
+                            body = body?.replace(search, replace);
+                        }
+                        else if (file) {
+                            log.debug(`using responseModifiers in: ${event.request.url}: ${file}`);
+                            body = await fs_1.default.promises.readFile(file, 'utf8');
+                        }
+                        if (headers) {
+                            for (const [name, value] of Object.entries(headers)) {
+                                responseHeaders.push({
+                                    name,
+                                    value,
+                                });
+                            }
+                        }
+                    }
+                    return { body, responseHeaders };
+                },
+            });
+        });
+        await interceptManager.intercept(...interceptions);
+        // Download responses.
+        if (this.downloadResponses.length) {
+            page.on('response', async (response) => {
+                if (!response.ok())
+                    return;
+                const url = response.url();
+                for (const { urlPattern, output, append } of this.downloadResponses) {
+                    if (!urlPattern.test(url))
+                        continue;
+                    try {
+                        const data = await response.buffer();
+                        if (data.byteLength > 0) {
+                            if (append) {
+                                const savePath = output.replaceAll('${id}', this.id.toString());
+                                if (!fs_1.default.existsSync(path_1.default.dirname(savePath))) {
+                                    await fs_1.default.promises.mkdir(path_1.default.dirname(output), { recursive: true });
+                                }
+                                log.debug(`appending response body ${data.byteLength} to: ${savePath}`);
+                                await fs_1.default.promises.appendFile(savePath, data);
+                            }
+                            else {
+                                if (!fs_1.default.existsSync(output)) {
+                                    await fs_1.default.promises.mkdir(output, { recursive: true });
+                                }
+                                const savePath = path_1.default.join(output, `${path_1.default.basename(new URL(url).pathname)}`);
+                                log.debug(`saving response body ${data.byteLength} to: ${savePath}`);
+                                await fs_1.default.promises.writeFile(savePath, data);
+                            }
+                        }
+                    }
+                    catch (err) {
+                        log.error(`downloadResponses error: ${err.stack}`);
+                    }
+                }
+            });
+        }
+        // Allow to change the setRequestInterception state from page.
+        const setRequestInterceptionFunction = async (value) => {
+            if (value === setRequestInterceptionState) {
+                return;
+            }
+            log.debug(`setRequestInterception to ${value}`);
+            try {
+                if (!value) {
+                    await interceptManager.disable();
+                }
+                else {
+                    await interceptManager.enable();
+                }
+                setRequestInterceptionState = value;
+            }
+            catch (err) {
+                log.error(`setRequestInterception error: ${err.stack}`);
+            }
+        };
+        await page.exposeFunction('setRequestInterception', setRequestInterceptionFunction);
+        await page.exposeFunction('jsonFetch', async (options, cacheKey = '', cacheTimeout = 0) => {
+            if (cacheKey) {
+                const ret = Session.jsonFetchCache.get(cacheKey);
+                if (ret) {
+                    return ret;
+                }
+            }
+            try {
+                if (options.validStatuses) {
+                    options.validateStatus = status => options.validStatuses.includes(status);
+                }
+                const { status, data, headers } = await (0, axios_1.default)(options);
+                if (options.responseType === 'stream') {
+                    if (options.downloadPath && !fs_1.default.existsSync(options.downloadPath)) {
+                        log.debug(`jsonFetch saving file to: ${options.downloadPath}`, headers['content-disposition']);
+                        await fs_1.default.promises.mkdir(path_1.default.dirname(options.downloadPath), {
+                            recursive: true,
+                        });
+                        const writer = fs_1.default.createWriteStream(options.downloadPath);
+                        await new Promise((resolve, reject) => {
+                            writer.on('error', err => reject(err));
+                            writer.on('close', () => resolve());
+                            data.pipe(writer);
+                        });
+                    }
+                    if (cacheKey) {
+                        Session.jsonFetchCache.set(cacheKey, { status }, cacheTimeout);
+                    }
+                    return { status, headers };
+                }
+                else {
+                    if (cacheKey) {
+                        Session.jsonFetchCache.set(cacheKey, { status, data }, cacheTimeout);
+                    }
+                    return { status, headers, data };
+                }
+            }
+            catch (err) {
+                const error = err.message;
+                log.warn(`jsonFetch error: ${error}`);
+                return { status: 500, error };
+            }
+        });
+        await page.exposeFunction('readLocalFile', (filePath, encoding) => {
+            filePath = path_1.default.resolve(process.cwd(), filePath);
+            return fs_1.default.promises.readFile(filePath, encoding);
+        });
+        // PeerConnectionExternal
+        await page.exposeFunction('createPeerConnectionExternal', 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        async (options) => {
+            const pc = new utils_1.PeerConnectionExternal(options);
+            return { id: pc.id };
+        });
+        await page.exposeFunction('callPeerConnectionExternalMethod', 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        async (id, name, arg) => {
+            const pc = utils_1.PeerConnectionExternal.get(id);
+            if (pc) {
+                return pc[name](arg);
+            }
+        });
+        // Simulate keypress
+        await page.exposeFunction('keypressText', async (selector, text, delay = 20) => {
+            await page.type(selector, text, { delay });
+        });
+        // Simulate mouse clicks
+        await page.exposeFunction('mouseClick', async (selector, x = 0, y = 0) => {
+            await page.click(selector, { offset: { x, y } });
+        });
+        const lorem = new lorem_ipsum_1.LoremIpsum({
+            sentencesPerParagraph: {
+                max: 4,
+                min: 1,
+            },
+            wordsPerSentence: {
+                max: 16,
+                min: 2,
+            },
+        });
+        await page.exposeFunction('loremIpsum', (count = 1) => lorem.generateSentences(count));
+        await page.exposeFunction('keypressRandomText', async (selector, count = 1, prefix = '', suffix = '', delay = 0) => {
+            const c = prefix + lorem.generateSentences(count) + suffix;
+            const frames = await page.frames();
+            for (const frame of frames) {
+                const el = await frame.$(selector);
+                if (el) {
+                    await el.focus();
+                    await frame.type(selector, c, { delay });
+                }
+            }
+        });
+        await page.exposeFunction('uploadFileFromUrl', async (fileUrl, selector) => {
+            const filename = (0, utils_1.sha256)(fileUrl) + '.' + fileUrl.split('.').slice(-1)[0];
+            const filePath = path_1.default.join(os_1.default.homedir(), '.webrtcperf/uploads', filename);
+            if (!fs_1.default.existsSync(filePath)) {
+                await (0, utils_1.downloadUrl)(fileUrl, undefined, filePath);
+            }
+            log.debug(`uploadFileFromUrl: ${filePath}`);
+            const frames = await page.frames();
+            for (const frame of frames) {
+                const el = await frame.$(selector);
+                if (el) {
+                    await el.uploadFile(filePath);
+                    break;
+                }
+            }
+        });
+        // add extra styles
+        if (this.extraCSS) {
+            log.debug(`Add extraCSS: ${this.extraCSS}`);
+            try {
+                await page.evaluateOnNewDocument((css) => {
+                    document.addEventListener('DOMContentLoaded', () => {
+                        const style = document.createElement('style');
+                        style.setAttribute('id', 'webrtcperf-extra-style');
+                        style.setAttribute('type', 'text/css');
+                        style.innerHTML = css;
+                        document.head.appendChild(style);
+                    });
+                }, this.extraCSS.replace(/important/g, '!important'));
+            }
+            catch (err) {
+                log.error(`Add extraCSS error: ${err.stack}`);
+            }
+        }
+        // add cookies
+        if (this.cookies) {
+            try {
+                await page.setCookie(...this.cookies);
+            }
+            catch (err) {
+                log.error(`Set cookies error: ${err.stack}`);
+            }
+        }
+        // Page logs and errors.
+        if (this.pageLogPath) {
+            try {
+                await fs_1.default.promises.mkdir(path_1.default.dirname(this.pageLogPath), {
+                    recursive: true,
+                });
+                saveFile = await fs_1.default.promises.open(this.pageLogPath, 'a');
+            }
+            catch (err) {
+                log.error(`error opening page log file: ${this.pageLogPath}: ${err.stack}`);
+            }
+        }
+        await page.exposeFunction('webrtcperf_serializedConsoleLog', async (type, text) => {
+            if (this.showPageLog || saveFile) {
+                try {
+                    await this.onPageMessage(index, type, text, saveFile);
+                }
+                catch (err) {
+                    log.error(`serializedConsoleLog error: ${err.stack}`);
+                }
+            }
+        });
+        if (this.showPageLog || saveFile) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            page.on('pageerror', async (error) => {
+                const text = `pageerror: ${error.message?.message || error.message} - ${error.message?.stack || error.stack}`;
+                await this.onPageMessage(index, 'error', text, saveFile);
+            });
+            page.on('requestfailed', async (request) => {
+                const err = (request.failure()?.errorText || '').trim();
+                if (err === 'net::ERR_ABORTED') {
+                    return;
+                }
+                const text = `${request.method()} ${request.url()}: ${err}`;
+                await this.onPageMessage(index, 'requestfailed', text, saveFile);
+            });
+        }
+        await page.exposeFunction('webrtcperf_sdpParse', (sdpStr) => sdpTransform.parse(sdpStr));
+        await page.exposeFunction('webrtcperf_sdpWrite', (sdp) => sdpTransform.write(sdp));
+        await page.exposeFunction('webrtcperf_startFakeScreenshare', async () => {
+            if (!this.browser)
+                return;
+            let screensharePage = page;
+            if (!this.useFakeMedia) {
+                if (!this.screensharePage) {
+                    screensharePage = this.screensharePage = await this.browser.newPage();
+                    await this.screensharePage.evaluateOnNewDocument(this.setupPageCmd(index, tabIndex, 'about:blank'));
+                    await this.screensharePage.evaluateOnNewDocument(fs_1.default.readFileSync((0, utils_1.resolvePackagePath)('@vpalmisano/webrtcperf-js'), 'utf8'));
+                    await screensharePage.exposeFunction('webrtcperf_keypressText', async (selector, text, delay = 20) => {
+                        await screensharePage.type(selector, text, { delay });
+                    });
+                    await screensharePage.exposeFunction('webrtcperf_keyPress', async (key) => {
+                        await screensharePage.keyboard.press(key);
+                    });
+                    await screensharePage.goto(`http${this.serverUseHttps ? 's' : ''}://localhost:${this.serverPort}/empty-page?auth=${this.serverSecret}&title=webrtcperf-screenshare`);
+                }
+            }
+            await screensharePage.evaluate(() => webrtcperf.startFakeScreenshare());
+        });
+        await page.exposeFunction('webrtcperf_stopFakeScreenshare', async () => {
+            if (!this.useFakeMedia && this.screensharePage) {
+                await this.screensharePage.close();
+                this.screensharePage = undefined;
+            }
+            else {
+                await page.evaluate(() => webrtcperf.stopFakeScreenshare());
+            }
+        });
+        // HTTP stats.
+        const resourcesStats = {
+            sentBytes: 0,
+            recvBytes: 0,
+            recvLatency: new stats_1.FastStats({ store_data: false }),
+            wsSentBytes: 0,
+            wsRecvBytes: 0,
+            wsRecvLatency: new stats_1.FastStats({ store_data: false }),
+        };
+        this.httpResourcesStats.set(index, resourcesStats);
+        const pendingRequests = new Map();
+        pageCDPSession.on('Network.requestWillBeSent', event => {
+            if (event.request.url.startsWith('data:'))
+                return;
+            const { requestId, request, timestamp } = event;
+            const sentBytes = request.postDataEntries?.reduce((acc, entry) => acc + (entry.bytes?.length || 0), 0);
+            //log.log('Network.requestWillBeSent', event.type, request.url, sentBytes)
+            if (sentBytes)
+                resourcesStats.sentBytes += sentBytes;
+            pendingRequests.set(requestId, { url: request.url, timestamp });
+        });
+        pageCDPSession.on('Network.responseReceived', event => {
+            const request = pendingRequests.get(event.requestId);
+            if (!request)
+                return;
+            const { response } = event;
+            if (response.fromDiskCache) {
+                pendingRequests.delete(event.requestId);
+                return;
+            }
+            resourcesStats.recvBytes += response.encodedDataLength;
+        });
+        pageCDPSession.on('Network.dataReceived', event => {
+            const request = pendingRequests.get(event.requestId);
+            if (!request)
+                return;
+            resourcesStats.recvBytes += event.encodedDataLength;
+        });
+        pageCDPSession.on('Network.loadingFinished', event => {
+            const request = pendingRequests.get(event.requestId);
+            if (!request)
+                return;
+            pendingRequests.delete(event.requestId);
+            const { timestamp } = event;
+            resourcesStats.recvLatency.push(timestamp - request.timestamp);
+        });
+        pageCDPSession.on('Network.webSocketCreated', event => {
+            pendingRequests.set(event.requestId, { url: event.url, timestamp: Date.now() });
+        });
+        pageCDPSession.on('Network.webSocketHandshakeResponseReceived', event => {
+            const request = pendingRequests.get(event.requestId);
+            if (!request)
+                return;
+            pendingRequests.delete(event.requestId);
+            resourcesStats.wsRecvLatency.push((Date.now() - request.timestamp) / 1000);
+        });
+        pageCDPSession.on('Network.webSocketFrameSent', event => {
+            resourcesStats.wsSentBytes += event.response.payloadData.length;
+        });
+        pageCDPSession.on('Network.webSocketFrameReceived', event => {
+            resourcesStats.wsRecvBytes += event.response.payloadData.length;
+        });
+        // hardware concurrency
+        if (this.hardwareConcurrency) {
+            const plugin = NavigatorHardwareConcurrency({ hardwareConcurrency: this.hardwareConcurrency });
+            await plugin.onPageCreated(page);
+        }
+        log.debug(`Page ${index + 1} "${url}" loading`);
+        const pageLoadTime = Date.now();
+        // open the page url
+        try {
+            await page.goto(url, {
+                waitUntil: 'domcontentloaded',
+                timeout: 60 * 1000,
+            });
+        }
+        catch (error) {
+            log.error(`Page ${index + 1} "${url}" load error: ${error.stack}`);
+            await page.close();
+            return;
+        }
+        // add to pages map
+        this.pages.set(index, page);
+        log.debug(`Page ${index + 1} "${url}" loaded in ${(Date.now() - pageLoadTime) / 1000}s`);
+        for (let i = 0; i < this.evaluateAfter.length; i++) {
+            await page.evaluate(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this.evaluateAfter[i].pageFunction, ...this.evaluateAfter[i].args);
+        }
+    }
+    async getNewPage(tabIndex) {
+        log.debug(`getNewPage ${tabIndex}`);
+        (0, assert_1.default)(this.context, 'NoBrowserContextCreated');
+        return await this.context.newPage();
+    }
+    async onPageMessage(index, type, text, saveFile) {
+        if (text.endsWith('net::ERR_BLOCKED_BY_CLIENT.Inspector')) {
+            return;
+        }
+        const isBlocked = this.blockedUrls.some(blockedUrl => (type === 'requestfailed' || text.search('FetchError') !== -1) && text.search(blockedUrl) !== -1);
+        if (isBlocked) {
+            return;
+        }
+        const color = PageLogColors[type] || 'grey';
+        const filter = this.pageLogFilter ? new RegExp(this.pageLogFilter, 'ig') : null;
+        if (!filter || text.match(filter)) {
+            const errorOrWarning = ['error', 'warning'].includes(type);
+            const isWebrtcPerf = text.startsWith('[webrtcperf');
+            if (saveFile) {
+                if (!errorOrWarning && !isWebrtcPerf && text.length > 1024) {
+                    text = text.slice(0, 1024) + `... +${text.length - 1024} bytes`;
+                }
+                await saveFile.write(`${new Date().toISOString()} [page ${index}] (${type}) ${text}\n`);
+            }
+            if (this.showPageLog) {
+                if (!errorOrWarning && !isWebrtcPerf && text.length > 256) {
+                    text = text.slice(0, 256) + `... +${text.length - 256} bytes`;
+                }
+                console.log((0, chalk_1.default) `{bold [page ${index}]} {${color} (${type}) ${text}}`);
+            }
+            if (type === 'error') {
+                this.pageErrors += 1;
+            }
+            else if (type === 'warn') {
+                this.pageWarnings += 1;
+            }
+        }
+    }
+    /**
+     * updateStats
+     */
+    async updateStats() {
+        if (!this.browser) {
+            this.stats = {};
+            return this.stats;
+        }
+        const collectedStats = {};
+        try {
+            const processStats = await (0, utils_1.getProcessStats)();
+            Object.assign(collectedStats, {
+                nodeCpu: processStats.cpu,
+                nodeMemory: processStats.memory,
+            });
+        }
+        catch (err) {
+            log.error(`node getProcessStats error: ${err.stack}`);
+        }
+        try {
+            const systemStats = (0, utils_1.getSystemStats)();
+            if (systemStats) {
+                collectedStats.usedCpu = systemStats.usedCpu;
+                collectedStats.usedMemory = systemStats.usedMemory;
+                collectedStats.usedGpu = systemStats.usedGpu;
+                if (collectedStats.usedCpu > 80) {
+                    log.warn(`High system CPU usage: ${collectedStats.usedCpu.toFixed(2)}%`);
+                }
+                if (collectedStats.usedMemory > 80) {
+                    log.warn(`High system memory usage: ${collectedStats.usedMemory.toFixed(2)}%`);
+                }
+            }
+        }
+        catch (err) {
+            log.error(`node getSystemStats error: ${err.stack}`);
+        }
+        const browserProcess = this.browser.process();
+        if (browserProcess) {
+            try {
+                const processStats = await (0, utils_1.getProcessStats)(browserProcess.pid, true);
+                Object.assign(collectedStats, processStats);
+            }
+            catch (err) {
+                log.error(`getProcessStats error: ${err.stack}`);
+            }
+        }
+        const pages = {};
+        const peerConnections = {};
+        const peerConnectionConnectionTime = {};
+        const peerConnectionDisconnectionTime = {};
+        const peerConnectionsCreated = {};
+        const peerConnectionsClosed = {};
+        const peerConnectionsConnected = {};
+        const peerConnectionsDisconnected = {};
+        const peerConnectionsFailed = {};
+        const peerConnectionsDelay = {};
+        const audioEndToEndDelayStats = {};
+        const audioStartFrameDelayStats = {};
+        const videoEndToEndDelayStats = {};
+        const screenEndToEndDelayStats = {};
+        const videoStartFrameDelayStats = {};
+        const screenStartFrameDelayStats = {};
+        const httpSentBytesStats = {};
+        const httpRecvBytesStats = {};
+        const httpRecvLatencyStats = {};
+        const wsSentBytesStats = {};
+        const wsRecvBytesStats = {};
+        const wsRecvLatencyStats = {};
+        const pageCpu = {};
+        const pageMemory = {};
+        const cpuPressureStats = {};
+        const videoWidth = {};
+        const videoHeight = {};
+        const videoBufferedTime = {};
+        const videoPlayingTime = {};
+        const videoBufferingTime = {};
+        const videoBufferingEvents = {};
+        const throttleUpValuesRate = {};
+        const throttleUpValuesDelay = {};
+        const throttleUpValuesLoss = {};
+        const throttleUpValuesQueue = {};
+        const throttleDownValuesRate = {};
+        const throttleDownValuesDelay = {};
+        const throttleDownValuesLoss = {};
+        const throttleDownValuesQueue = {};
+        const customStats = {};
+        await Promise.allSettled([...this.pages.entries()].map(async ([pageIndex, page]) => {
+            try {
+                // Collect stats from the page.
+                const { peerConnectionStats, audioEndToEndDelay, videoEndToEndDelay, cpuPressure, videoStats, customMetrics, } = await page.evaluate(async () => ({
+                    peerConnectionStats: await webrtcperf.collectPeerConnectionStats(),
+                    audioEndToEndDelay: webrtcperf.collectAudioEndToEndStats(),
+                    videoEndToEndDelay: webrtcperf.collectVideoEndToEndStats(),
+                    cpuPressure: webrtcperf.collectCpuPressure(),
+                    videoStats: webrtcperf.collectVideoStats(),
+                    customMetrics: 'collectCustomMetrics' in window ? webrtcperf.collectCustomMetrics() : null,
+                }));
+                const { participantName } = peerConnectionStats;
+                const httpResourcesStats = this.httpResourcesStats.get(pageIndex);
+                // Get host from the first collected remote address.
+                if (!peerConnectionStats.signalingHost && peerConnectionStats.stats.length) {
+                    const values = Object.values(peerConnectionStats.stats[0]);
+                    if (values.length) {
+                        peerConnectionStats.signalingHost = await (0, utils_1.resolveIP)(values[0].remoteAddress);
+                    }
+                }
+                const { stats, activePeerConnections, signalingHost } = peerConnectionStats;
+                // Calculate stats keys.
+                const hostKey = (0, rtcstats_1.rtcStatKey)({
+                    hostName: signalingHost,
+                    participantName,
+                });
+                const pageKey = (0, rtcstats_1.rtcStatKey)({
+                    pageIndex,
+                    hostName: signalingHost,
+                    participantName,
+                });
+                // Set pages counter.
+                (0, utils_1.increaseKey)(pages, hostKey, 1);
+                // Set peerConnections counters.
+                (0, utils_1.increaseKey)(peerConnections, pageKey, activePeerConnections);
+                (0, utils_1.increaseKey)(peerConnectionConnectionTime, pageKey, peerConnectionStats.peerConnectionConnectionTime);
+                (0, utils_1.increaseKey)(peerConnectionDisconnectionTime, pageKey, peerConnectionStats.peerConnectionDisconnectionTime);
+                (0, utils_1.increaseKey)(peerConnectionsCreated, pageKey, peerConnectionStats.peerConnectionsCreated);
+                (0, utils_1.increaseKey)(peerConnectionsClosed, pageKey, peerConnectionStats.peerConnectionsClosed);
+                (0, utils_1.increaseKey)(peerConnectionsConnected, pageKey, peerConnectionStats.peerConnectionsConnected);
+                (0, utils_1.increaseKey)(peerConnectionsDisconnected, pageKey, peerConnectionStats.peerConnectionsDisconnected);
+                (0, utils_1.increaseKey)(peerConnectionsFailed, pageKey, peerConnectionStats.peerConnectionsFailed);
+                (0, utils_1.increaseKey)(peerConnectionsDelay, pageKey, peerConnectionStats.peerConnectionsDelay);
+                // E2E stats.
+                if (audioEndToEndDelay) {
+                    audioEndToEndDelayStats[pageKey] = audioEndToEndDelay.delay;
+                    audioStartFrameDelayStats[pageKey] = audioEndToEndDelay.startFrameDelay;
+                }
+                if (videoEndToEndDelay) {
+                    videoEndToEndDelayStats[pageKey] = videoEndToEndDelay.videoDelay;
+                    videoStartFrameDelayStats[pageKey] = videoEndToEndDelay.videoStartFrameDelay;
+                    screenEndToEndDelayStats[pageKey] = videoEndToEndDelay.screenDelay;
+                    screenStartFrameDelayStats[pageKey] = videoEndToEndDelay.screenStartFrameDelay;
+                }
+                // HTTP stats.
+                if (httpResourcesStats) {
+                    if (httpResourcesStats.sentBytes > 0)
+                        httpSentBytesStats[pageKey] = httpResourcesStats.sentBytes;
+                    if (httpResourcesStats.recvBytes > 0)
+                        httpRecvBytesStats[pageKey] = httpResourcesStats.recvBytes;
+                    if (httpResourcesStats.recvLatency.length)
+                        httpRecvLatencyStats[pageKey] = httpResourcesStats.recvLatency.amean();
+                    if (httpResourcesStats.wsSentBytes > 0)
+                        wsSentBytesStats[pageKey] = httpResourcesStats.wsSentBytes;
+                    if (httpResourcesStats.wsRecvBytes > 0)
+                        wsRecvBytesStats[pageKey] = httpResourcesStats.wsRecvBytes;
+                    if (httpResourcesStats.wsRecvLatency.length)
+                        wsRecvLatencyStats[pageKey] = httpResourcesStats.wsRecvLatency.amean();
+                }
+                if (cpuPressure !== undefined)
+                    cpuPressureStats[pageKey] = cpuPressure;
+                if (videoStats) {
+                    videoWidth[pageKey] = videoStats.width;
+                    videoHeight[pageKey] = videoStats.height;
+                    videoBufferedTime[pageKey] = videoStats.bufferedTime;
+                    videoPlayingTime[pageKey] = videoStats.playingTime;
+                    videoBufferingTime[pageKey] = videoStats.bufferingTime;
+                    videoBufferingEvents[pageKey] = videoStats.bufferingEvents;
+                }
+                // Collect RTC stats.
+                for (const s of stats) {
+                    for (const [trackId, value] of Object.entries(s)) {
+                        try {
+                            (0, rtcstats_1.updateRtcStats)(collectedStats, pageIndex, trackId, value, signalingHost, participantName);
+                        }
+                        catch (err) {
+                            log.error(`updateRtcStats error for ${trackId}: ${err.stack}`, err);
+                        }
+                    }
+                }
+                // Collect custom metrics.
+                if (customMetrics) {
+                    for (const [name, value] of Object.entries(customMetrics)) {
+                        if (!customStats[name]) {
+                            customStats[name] = {};
+                        }
+                        customStats[name][pageKey] = value;
+                    }
+                }
+                // Collect page metrics
+                /* const metrics = await page.metrics()
+              if (metrics.Timestamp) {
+                const lastMetrics = this.pagesMetrics.get(pageIndex)
+                if (lastMetrics?.Timestamp) {
+                  const elapsedTime = metrics.Timestamp - lastMetrics.Timestamp
+                  if (elapsedTime > 10) {
+                    const durationDiff =
+                      metricsTotalDuration(metrics) -
+                      metricsTotalDuration(lastMetrics)
+                    const usage = (100 * durationDiff) / elapsedTime
+                    pageCpu[pageKey] = usage
+                    pageMemory[pageKey] = (metrics.JSHeapUsedSize || 0) / 1e6
+                    this.pagesMetrics.set(pageIndex, metrics)
+                  }
+                } else {
+                  this.pagesMetrics.set(pageIndex, metrics)
+                }
+              } */
+                pageCpu[pageKey] = collectedStats.cpu / this.tabsPerSession;
+                pageMemory[pageKey] = collectedStats.memory / this.tabsPerSession;
+                // Collect throttle metrics
+                const throttleUpValues = (0, throttler_1.getSessionThrottleValues)(this.throttleIndex, 'up');
+                throttleUpValuesRate[pageKey] = throttleUpValues.rate || 0;
+                throttleUpValuesDelay[pageKey] = throttleUpValues.delay || 0;
+                throttleUpValuesLoss[pageKey] = throttleUpValues.loss || 0;
+                throttleUpValuesQueue[pageKey] = throttleUpValues.queue || 0;
+                const throttleDownValues = (0, throttler_1.getSessionThrottleValues)(this.throttleIndex, 'down');
+                throttleDownValuesRate[pageKey] = throttleDownValues.rate || 0;
+                throttleDownValuesDelay[pageKey] = throttleDownValues.delay || 0;
+                throttleDownValuesLoss[pageKey] = throttleDownValues.loss || 0;
+                throttleDownValuesQueue[pageKey] = throttleDownValues.queue || 0;
+            }
+            catch (err) {
+                const error = err;
+                if (error.message.includes('Execution context was destroyed, most likely because of a navigation.')) {
+                    log.warn(`collectPeerConnectionStats for page ${pageIndex} error: ${error.message}`);
+                }
+                else {
+                    log.error(`collectPeerConnectionStats for page ${pageIndex} error: ${error.stack}`);
+                }
+            }
+        }));
+        Object.assign(collectedStats, {
+            pages,
+            errors: this.pageErrors,
+            warnings: this.pageWarnings,
+            peerConnections,
+            peerConnectionConnectionTime,
+            peerConnectionDisconnectionTime,
+            peerConnectionsConnected,
+            peerConnectionsCreated,
+            peerConnectionsClosed,
+            peerConnectionsDisconnected,
+            peerConnectionsFailed,
+            peerConnectionsDelay,
+            audioEndToEndDelay: audioEndToEndDelayStats,
+            audioStartFrameDelay: audioStartFrameDelayStats,
+            videoEndToEndDelay: videoEndToEndDelayStats,
+            videoStartFrameDelay: videoStartFrameDelayStats,
+            screenEndToEndDelay: screenEndToEndDelayStats,
+            screenStartFrameDelay: screenStartFrameDelayStats,
+            httpSentBytes: httpSentBytesStats,
+            httpRecvBytes: httpRecvBytesStats,
+            httpRecvLatency: httpRecvLatencyStats,
+            wsSentBytes: wsSentBytesStats,
+            wsRecvBytes: wsRecvBytesStats,
+            wsRecvLatency: wsRecvLatencyStats,
+            cpuPressure: cpuPressureStats,
+            videoWidth,
+            videoHeight,
+            videoBufferedTime,
+            videoPlayingTime,
+            videoBufferingTime,
+            videoBufferingEvents,
+            pageCpu,
+            pageMemory,
+            throttleUpRate: throttleUpValuesRate,
+            throttleUpDelay: throttleUpValuesDelay,
+            throttleUpLoss: throttleUpValuesLoss,
+            throttleUpQueue: throttleUpValuesQueue,
+            throttleDownRate: throttleDownValuesRate,
+            throttleDownDelay: throttleDownValuesDelay,
+            throttleDownLoss: throttleDownValuesLoss,
+            throttleDownQueue: throttleDownValuesQueue,
+            ...customStats,
+        });
+        if (pages.size < this.pages.size) {
+            log.warn(`updateStats collected pages ${pages.size} < ${this.pages.size}`);
+        }
+        this.stats = collectedStats;
+        return this.stats;
+    }
+    /**
+     * stop
+     */
+    async stop() {
+        if (!this.running) {
+            return;
+        }
+        this.running = false;
+        log.debug(`${this.id} stop`);
+        if (this.stopPortForwarder) {
+            this.stopPortForwarder();
+        }
+        if (this.browser) {
+            // close the opened tabs
+            log.debug(`${this.id} closing ${this.pages.size} pages`);
+            await Promise.allSettled([...this.pages.values()].map(page => {
+                return page.close({ runBeforeUnload: true });
+            }));
+            if (this.pages.size > 0) {
+                const now = Date.now();
+                const maxWaitTime = 1000 * this.pages.size;
+                while (this.pages.size > 0 && Date.now() - now < maxWaitTime) {
+                    log.debug(`${this.id} waiting for ${this.pages.size} pages to close`);
+                    await (0, utils_1.sleep)(200);
+                }
+                if (this.pages.size > 0) {
+                    log.warn(`${this.id} timeout closing ${this.pages.size} pages`);
+                }
+            }
+            if (this.screensharePage) {
+                await this.screensharePage.close();
+                this.screensharePage = undefined;
+            }
+            this.browser.removeAllListeners();
+            if (this.chromiumUrl) {
+                log.debug(`${this.id} disconnect from browser`);
+                try {
+                    await this.browser.disconnect();
+                }
+                catch (err) {
+                    log.warn(`${this.id} browser disconnect error: ${err.message}`);
+                }
+            }
+            else {
+                const pid = this.browser.process()?.pid;
+                if (pid) {
+                    log.debug(`${this.id} closing browser (pid: ${pid})`);
+                    try {
+                        await this.browser.close();
+                    }
+                    catch (err) {
+                        log.error(`${this.id} browser close error: ${err.stack}`);
+                    }
+                    await (0, utils_1.waitStopProcess)(pid, 5000);
+                }
+            }
+            this.pages.clear();
+            this.pagesMetrics.clear();
+            this.browser = undefined;
+        }
+        this.emit('stop', this.id);
+    }
+    /**
+     * pageScreenshot
+     * @param {number} pageIndex
+     * @param {String} format The image format (png|jpeg|webp).
+     * @return {String}
+     */
+    async pageScreenshot(pageIndex = 0, format = 'webp') {
+        log.debug(`pageScreenshot ${this.id}-${pageIndex}`);
+        const index = this.id + pageIndex;
+        const page = this.pages.get(index);
+        if (!page) {
+            throw new Error(`Page ${index} not found`);
+        }
+        const filePath = `/tmp/screenshot-${index}.${format}`;
+        await page.screenshot({
+            path: filePath,
+            fullPage: true,
+        });
+        return filePath;
+    }
+}
+exports.Session = Session;
+//# sourceMappingURL=session.js.map