@wdio/lighthouse-service 9.0.0-alpha.369 → 9.0.0

package/build/gatherer/trace.js

@@ -1,233 +0,0 @@
-import { EventEmitter } from 'node:events';
-import NetworkRecorder from 'lighthouse/lighthouse-core/lib/network-recorder.js';
-import NetworkMonitor from 'lighthouse/lighthouse-core/gather/driver/network-monitor.js';
-import ProtocolSession from 'lighthouse/lighthouse-core/fraggle-rock/gather/session.js';
-import { waitForFullyLoaded } from 'lighthouse/lighthouse-core/gather/driver/wait-for-condition.js';
-import logger from '@wdio/logger';
-import registerPerformanceObserverInPage from '../scripts/registerPerformanceObserverInPage.js';
-import { FRAME_LOAD_START_TIMEOUT, TRACING_TIMEOUT, MAX_TRACE_WAIT_TIME, CLICK_TRANSITION, NETWORK_RECORDER_EVENTS } from '../constants.js';
-import { isSupportedUrl } from '../utils.js';
-const log = logger('@wdio/lighthouse-service:TraceGatherer');
-export default class TraceGatherer extends EventEmitter {
-    _session;
-    _page;
-    _driver;
-    _failingFrameLoadIds = [];
-    _pageLoadDetected = false;
-    _networkListeners = {};
-    _frameId;
-    _loaderId;
-    _pageUrl;
-    _networkStatusMonitor;
-    _networkMonitor;
-    _protocolSession;
-    _trace;
-    _traceStart;
-    _clickTraceTimeout;
-    _waitConditionPromises = [];
-    constructor(_session, _page, _driver) {
-        super();
-        this._session = _session;
-        this._page = _page;
-        this._driver = _driver;
-        NETWORK_RECORDER_EVENTS.forEach((method) => {
-            this._networkListeners[method] = (params) => this._networkStatusMonitor.dispatch({ method, params });
-        });
-        this._protocolSession = new ProtocolSession(_session);
-        this._networkMonitor = new NetworkMonitor(_session);
-    }
-    async startTracing(url) {
-        /**
-         * delete old trace
-         */
-        delete this._trace;
-        /**
-         * register listener for network status monitoring
-         */
-        this._networkStatusMonitor = new NetworkRecorder();
-        NETWORK_RECORDER_EVENTS.forEach((method) => {
-            this._session.on(method, this._networkListeners[method]);
-        });
-        this._traceStart = Date.now();
-        log.info(`Start tracing frame with url ${url}`);
-        await this._driver.beginTrace();
-        /**
-         * if this tracing was started from a click transition
-         * then we want to discard page trace if no load detected
-         */
-        if (url === CLICK_TRANSITION) {
-            log.info('Start checking for page load for click');
-            this._clickTraceTimeout = setTimeout(async () => {
-                log.info('No page load detected, canceling trace');
-                return this.finishTracing();
-            }, FRAME_LOAD_START_TIMEOUT);
-        }
-        /**
-         * register performance observer
-         */
-        await this._page.evaluateOnNewDocument(registerPerformanceObserverInPage);
-        this._waitConditionPromises.push(waitForFullyLoaded(this._protocolSession, this._networkMonitor, { timedOut: 1 }));
-    }
-    /**
-     * store frame id of frames that are being traced
-     */
-    async onFrameNavigated(msgObj) {
-        if (!this.isTracing) {
-            return;
-        }
-        /**
-         * page load failed, cancel tracing
-         */
-        if (this._failingFrameLoadIds.includes(msgObj.frame.url)) {
-            this._waitConditionPromises = [];
-            this._frameId = '"unsuccessful loaded frame"';
-            this.finishTracing();
-            this.emit('tracingError', new Error(`Page with url "${msgObj.frame.url}" failed to load`));
-            if (this._clickTraceTimeout) {
-                clearTimeout(this._clickTraceTimeout);
-            }
-        }
-        /**
-         * ignore event if
-         */
-        if (
-        // we already detected a frameId before
-        this._frameId ||
-            // the event was thrown for a sub frame (e.g. iframe)
-            msgObj.frame.parentId ||
-            // we don't support the url of given frame
-            !isSupportedUrl(msgObj.frame.url)) {
-            log.info(`Ignore navigated frame with url ${msgObj.frame.url}`);
-            return;
-        }
-        this._frameId = msgObj.frame.id;
-        this._loaderId = msgObj.frame.loaderId;
-        this._pageUrl = msgObj.frame.url;
-        log.info(`Page load detected: ${this._pageUrl}, set frameId ${this._frameId}, set loaderId ${this._loaderId}`);
-        /**
-         * clear click tracing timeout if it's still waiting
-         *
-         * the reason we have to tie this to Page.frameNavigated instead of Page.frameStartedLoading
-         * is because the latter can sometimes occur without the former, which will cause a hang
-         * e.g. with duolingo's sign-in button
-         */
-        if (this._clickTraceTimeout && !this._pageLoadDetected) {
-            log.info('Page load detected for click, clearing click trace timeout}');
-            this._pageLoadDetected = true;
-            clearTimeout(this._clickTraceTimeout);
-        }
-        this.emit('tracingStarted', msgObj.frame.id);
-    }
-    /**
-     * once the page load event has fired, we can grab some performance
-     * metrics and timing
-     */
-    async onLoadEventFired() {
-        if (!this.isTracing) {
-            return;
-        }
-        /**
-         * Ensure that page is fully loaded and all metrics can be calculated.
-         */
-        const loadPromise = Promise.all(this._waitConditionPromises).then(() => async () => {
-            /**
-             * ensure that we trace at least for 5s to ensure that we can
-             * calculate "interactive"
-             */
-            const minTraceTime = TRACING_TIMEOUT - (Date.now() - (this._traceStart || 0));
-            if (minTraceTime > 0) {
-                log.info(`page load happen to quick, waiting ${minTraceTime}ms more`);
-                await new Promise((resolve) => setTimeout(resolve, minTraceTime));
-            }
-            return this.completeTracing();
-        });
-        const cleanupFn = await Promise.race([
-            loadPromise,
-            this.waitForMaxTimeout()
-        ]);
-        this._waitConditionPromises = [];
-        return cleanupFn();
-    }
-    onFrameLoadFail(request) {
-        const frame = request.frame();
-        if (frame) {
-            this._failingFrameLoadIds.push(frame.url());
-        }
-    }
-    get isTracing() {
-        return typeof this._traceStart === 'number';
-    }
-    /**
-     * once tracing has finished capture trace logs into memory
-     */
-    async completeTracing() {
-        const traceDuration = Date.now() - (this._traceStart || 0);
-        log.info(`Tracing completed after ${traceDuration}ms, capturing performance data for frame ${this._frameId}`);
-        /**
-         * download all tracing data
-         * in case it fails, continue without capturing any data
-         */
-        try {
-            const traceEvents = await this._driver.endTrace();
-            /**
-             * modify pid of renderer frame to be the same as where tracing was started
-             * possibly related to https://github.com/GoogleChrome/lighthouse/issues/6968
-             */
-            const startedInBrowserEvt = traceEvents.traceEvents.find(e => e.name === 'TracingStartedInBrowser');
-            const mainFrame = (startedInBrowserEvt &&
-                startedInBrowserEvt.args &&
-                startedInBrowserEvt.args.data.frames?.find((frame) => !frame.parent));
-            if (mainFrame && mainFrame.processId) {
-                const threadNameEvt = traceEvents.traceEvents.find(e => e.ph === 'R' &&
-                    e.cat === 'blink.user_timing' && e.name === 'navigationStart' && e.args.data.isLoadingMainFrame);
-                if (threadNameEvt) {
-                    log.info(`Replace mainFrame process id ${mainFrame.processId} with actual thread process id ${threadNameEvt.pid}`);
-                    mainFrame.processId = threadNameEvt.pid;
-                }
-                else {
-                    log.info(`Couldn't replace mainFrame process id ${mainFrame.processId} with actual thread process id`);
-                }
-            }
-            this._trace = {
-                ...traceEvents,
-                frameId: this._frameId,
-                loaderId: this._loaderId,
-                pageUrl: this._pageUrl,
-                traceStart: this._traceStart,
-                traceEnd: Date.now()
-            };
-            this.emit('tracingComplete', this._trace);
-            this.finishTracing();
-        }
-        catch (err) {
-            log.error(`Error capturing tracing logs: ${err.stack}`);
-            this.emit('tracingError', err);
-            return this.finishTracing();
-        }
-    }
-    /**
-     * clear tracing states and emit tracingFinished
-     */
-    finishTracing() {
-        log.info(`Tracing for ${this._frameId} completed`);
-        this._pageLoadDetected = false;
-        /**
-         * clean up the listeners
-         */
-        NETWORK_RECORDER_EVENTS.forEach((method) => this._session.off(method, this._networkListeners[method]));
-        delete this._networkStatusMonitor;
-        delete this._traceStart;
-        delete this._frameId;
-        delete this._loaderId;
-        delete this._pageUrl;
-        this._failingFrameLoadIds = [];
-        this._waitConditionPromises = [];
-        this.emit('tracingFinished');
-    }
-    waitForMaxTimeout(maxWaitForLoadedMs = MAX_TRACE_WAIT_TIME) {
-        return new Promise((resolve) => setTimeout(resolve, maxWaitForLoadedMs)).then(() => async () => {
-            log.error('Neither network nor CPU idle time could be detected within timeout, wrapping up tracing');
-            return this.completeTracing();
-        });
-    }
-}

package/build/handler/network.js

@@ -1,133 +0,0 @@
-import { IGNORED_URLS } from '../constants.js';
-export default class NetworkHandler {
-    requestLog = { requests: [] };
-    requestTypes = {};
-    cachedFirstRequest;
-    constructor(session) {
-        session.on('Network.dataReceived', this.onDataReceived.bind(this));
-        session.on('Network.responseReceived', this.onNetworkResponseReceived.bind(this));
-        session.on('Network.requestWillBeSent', this.onNetworkRequestWillBeSent.bind(this));
-        session.on('Page.frameNavigated', this.onPageFrameNavigated.bind(this));
-    }
-    findRequest(params) {
-        let request = this.requestLog.requests.find((req) => req.id === params.requestId);
-        /**
-         * If no match is found, check if the corresponding request is the cached first request
-         */
-        if (!request && this.cachedFirstRequest && this.cachedFirstRequest.id === params.requestId) {
-            request = this.cachedFirstRequest;
-        }
-        return request;
-    }
-    onDataReceived(params) {
-        const request = this.findRequest(params);
-        /**
-         * ensure that
-         *  - a requestWillBeSent event was triggered before
-         *  - the request type is accurate and known (sometimes this is not the case when `Network.requestWillBeSent` is triggered)
-         */
-        if (!request || !request.type || !this.requestTypes[request.type]) {
-            return;
-        }
-        const type = request.type;
-        const requestType = this.requestTypes[type] || {};
-        requestType.size += params.dataLength;
-        requestType.encoded += params.encodedDataLength;
-    }
-    onNetworkResponseReceived(params) {
-        const request = this.findRequest(params);
-        /**
-         * ensure that a requestWillBeSent event was triggered before
-         */
-        if (!request) {
-            return;
-        }
-        request.statusCode = params.response.status;
-        request.requestHeaders = params.response.requestHeaders;
-        request.responseHeaders = params.response.headers;
-        request.timing = params.response.timing;
-        request.type = params.type;
-    }
-    onNetworkRequestWillBeSent(params) {
-        let isFirstRequestOfFrame = false;
-        if (
-        /**
-         * A new page was opened when request type is a document.
-         * The first request is sent before the Page.frameNavigated event is triggered,
-         * so this request must be cached to be able to add it to the requestLog later.
-         */
-        params.type === 'Document' &&
-            /**
-             * ensure that only page loads triggered by non scripts (devtools only) are considered
-             * new page loads
-             */
-            params.initiator.type === 'other' &&
-            /**
-             * ignore pages not initated by the user
-             */
-            IGNORED_URLS.filter((url) => params.request.url.startsWith(url)).length === 0) {
-            isFirstRequestOfFrame = true;
-            /**
-             * reset the request type sizes
-             */
-            this.requestTypes = {};
-        }
-        const log = {
-            id: params.requestId,
-            url: params.request.url,
-            method: params.request.method
-        };
-        if (params.redirectResponse) {
-            log.redirect = {
-                url: params.redirectResponse.url,
-                statusCode: params.redirectResponse.status,
-                requestHeaders: params.redirectResponse.requestHeaders,
-                responseHeaders: params.redirectResponse.headers,
-                timing: params.redirectResponse.timing
-            };
-        }
-        if (params.type) {
-            const requestType = this.requestTypes[params.type];
-            if (!requestType) {
-                this.requestTypes[params.type] = {
-                    size: 0,
-                    encoded: 0,
-                    count: 1
-                };
-            }
-            else if (requestType) {
-                requestType.count++;
-            }
-        }
-        if (isFirstRequestOfFrame) {
-            log.loaderId = params.loaderId;
-            this.cachedFirstRequest = log;
-            return;
-        }
-        return this.requestLog.requests.push(log);
-    }
-    onPageFrameNavigated(params) {
-        /**
-         * Only create a requestLog for pages that don't have a parent frame.
-         * I.e. iframes are ignored
-         */
-        if (!params.frame.parentId && IGNORED_URLS.filter((url) => params.frame.url.startsWith(url)).length === 0) {
-            this.requestLog = {
-                id: params.frame.loaderId,
-                url: params.frame.url,
-                requests: []
-            };
-            /**
-             * Add the first request that was cached before the actual requestLog could be created
-             */
-            if (this.cachedFirstRequest && this.cachedFirstRequest.loaderId === params.frame.loaderId) {
-                /**
-                 * Delete the loaderId of the first request so that all request data has the same structure
-                 */
-                delete this.cachedFirstRequest.loaderId;
-                this.requestLog.requests.push(this.cachedFirstRequest);
-                this.cachedFirstRequest = undefined;
-            }
-        }
-    }
-}

package/build/lighthouse/cri.js

@@ -1,29 +0,0 @@
-import CriConnection from 'lighthouse/lighthouse-core/gather/connections/cri.js';
-const DEFAULT_HOSTNAME = 'localhost';
-const DEFAULT_PORT = '9222';
-/**
- * this class got patched to enable connecting to a remote path like
- * ws://192.168.0.39:4444/session/349a44a32846c2659c703e71403bd472/se/cdp
- * as it requires to attach to a session before.
- */
-export default class ChromeProtocolPatched extends CriConnection {
-    _sessionId;
-    /**
-     * Add constructor for typing safety
-     * @param {number=} port Optional port number. Defaults to 9222;
-     * @param {string=} hostname Optional hostname. Defaults to localhost.
-     * @constructor
-     */
-    constructor(port = DEFAULT_PORT, hostname = DEFAULT_HOSTNAME) {
-        super(port, hostname);
-    }
-    setSessionId(sessionId) {
-        this._sessionId = sessionId;
-    }
-    /**
-     * force every command to be send with the given session id
-     */
-    sendCommand(method, sessionId, ...paramArgs) {
-        return super.sendCommand(method, sessionId || this._sessionId, ...paramArgs);
-    }
-}

package/build/scripts/collectMetaElements.js

@@ -1,37 +0,0 @@
-export default function collectMetaElements() {
-    const selector = 'head meta';
-    const realMatchesFn = window.Element.prototype.matches;
-    const metas = [];
-    const _findAllElements = (nodes) => {
-        // eslint-disable-next-line no-cond-assign
-        for (let i = 0, el; el = nodes[i]; ++i) {
-            if (!selector || realMatchesFn.call(el, selector)) {
-                metas.push(el);
-            }
-            // If the element has a shadow root, dig deeper.
-            if (el.shadowRoot) {
-                _findAllElements(el.shadowRoot.querySelectorAll('*'));
-            }
-        }
-    };
-    _findAllElements(document.querySelectorAll('*'));
-    return metas.map(meta => {
-        const getAttribute = (name) => {
-            const attr = meta.attributes.getNamedItem(name);
-            if (!attr) {
-                return;
-            }
-            return attr.value;
-        };
-        return {
-            // @ts-ignore
-            name: meta.name.toLowerCase(),
-            // @ts-ignore
-            content: meta.content,
-            property: getAttribute('property'),
-            // @ts-ignore
-            httpEquiv: meta.httpEquiv ? meta.httpEquiv.toLowerCase() : undefined,
-            charset: getAttribute('charset'),
-        };
-    });
-}

package/build/scripts/registerPerformanceObserverInPage.js

@@ -1,23 +0,0 @@
-/**
- * Used by _waitForCPUIdle and executed in the context of the page, updates the ____lastLongTask
- * property on window to the end time of the last long task.
- */
-export default function registerPerformanceObserverInPage() {
-    window.____lastLongTask = window.performance.now();
-    const observer = new window.PerformanceObserver(entryList => {
-        const entries = entryList.getEntries();
-        for (const entry of entries) {
-            if (entry.entryType === 'longtask') {
-                const taskEnd = entry.startTime + entry.duration;
-                window.____lastLongTask = Math.max(window.____lastLongTask, taskEnd);
-            }
-        }
-    });
-    observer.observe({ entryTypes: ['longtask'] });
-    // HACK: A PerformanceObserver will be GC'd if there are no more references to it, so attach it to
-    // window to ensure we still receive longtask notifications. See https://crbug.com/742530.
-    // For an example test of this behavior see https://gist.github.com/patrickhulce/69d8bed1807e762218994b121d06fea6.
-    //   FIXME COMPAT: This hack isn't neccessary as of Chrome 62.0.3176.0
-    //   https://bugs.chromium.org/p/chromium/issues/detail?id=742530#c7
-    window.____lhPerformanceObserver = observer;
-}

package/build/types.js

@@ -1 +0,0 @@
-export {};

package/build/utils.js

@@ -1,64 +0,0 @@
-import Driver from 'lighthouse/lighthouse-core/gather/driver.js';
-import ChromeProtocol from './lighthouse/cri.js';
-import { IGNORED_URLS, UNSUPPORTED_ERROR_MESSAGE } from './constants.js';
-const CUSTOM_COMMANDS = [
-    'getMetrics',
-    'startTracing',
-    'getDiagnostics',
-    'getCoverageReport',
-    'enablePerformanceAudits',
-    'disablePerformanceAudits',
-    'getMainThreadWorkBreakdown',
-    'checkPWA'
-];
-export function setUnsupportedCommand(browser) {
-    for (const command of CUSTOM_COMMANDS) {
-        browser.addCommand(command, /* istanbul ignore next */ () => {
-            throw new Error(UNSUPPORTED_ERROR_MESSAGE);
-        });
-    }
-}
-/**
- * Create a sum of a specific key from a list of objects
- * @param list list of key/value objects
- * @param key  key of value to be summed up
- */
-export function sumByKey(list, key) {
-    return list.map((data) => data[key]).reduce((acc, val) => acc + val, 0);
-}
-/**
- * check if url is supported for tracing
- * @param  {string}  url to check for
- * @return {Boolean}     true if url was opened by user
- */
-export function isSupportedUrl(url) {
-    return IGNORED_URLS.filter((ignoredUrl) => url.startsWith(ignoredUrl)).length === 0;
-}
-/**
- * Either request the page list directly from the browser or if Selenium
- * or Selenoid is used connect to a target manually
- */
-export async function getLighthouseDriver(session, target) {
-    const connection = session.connection();
-    if (!connection) {
-        throw new Error('Couldn\'t find a CDP connection');
-    }
-    const cUrl = new URL(connection.url());
-    const cdpConnection = new ChromeProtocol(cUrl.port, cUrl.hostname);
-    /**
-     * only create a new DevTools session if our WebSocket url doesn't already indicate
-     * that we are using one
-     */
-    if (!cUrl.pathname.startsWith('/devtools/browser')) {
-        await cdpConnection._connectToSocket({
-            webSocketDebuggerUrl: connection.url(),
-            id: (await target.asPage()).mainFrame()._id
-        });
-        const { sessionId } = await cdpConnection.sendCommand('Target.attachToTarget', undefined, { targetId: (await target.asPage()).mainFrame()._id, flatten: true });
-        cdpConnection.setSessionId(sessionId);
-        return new Driver(cdpConnection);
-    }
-    const list = await cdpConnection._runJsonCommand('list');
-    await cdpConnection._connectToSocket(list[0]);
-    return new Driver(cdpConnection);
-}