@elastic/synthetics 1.0.0-beta.24 → 1.0.0-beta.27

package/dist/options.js

@@ -27,7 +27,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeOptions = void 0;
+exports.parseThrottling = exports.normalizeOptions = void 0;
 const deepmerge_1 = __importDefault(require("deepmerge"));
 const config_1 = require("./config");
 const helpers_1 = require("./helpers");
@@ -86,23 +86,77 @@ function normalizeOptions(cliArgs) {
     const config = cliArgs.config || !cliArgs.inline
         ? (0, config_1.readConfig)(options.environment, cliArgs.config)
         : {};
+    /**
+     * Order of preference for options that are used while running are
+     * 1. Local options configured via Runner API
+     * 2. CLI flags
+     * 3. Configuration file
+     */
     options.params = Object.freeze((0, deepmerge_1.default)(config.params, cliArgs.params || {}));
     /**
-     * Favor playwright options passed via cli to inline playwright options
+     * Merge playwright options from CLI and Synthetics config
+     * and prefer individual options over other option
      */
-    options.playwrightOptions = deepmerge_1.default.all([
-        config.playwrightOptions || {},
-        cliArgs.playwrightOptions || {},
-        {
-            headless: cliArgs.headless,
-            chromiumSandbox: cliArgs.sandbox,
-            ignoreHTTPSErrors: cliArgs.ignoreHttpsErrors,
-        },
-    ]);
+    const playwrightOpts = (0, deepmerge_1.default)(config.playwrightOptions, cliArgs.playwrightOptions || {});
+    options.playwrightOptions = {
+        ...playwrightOpts,
+        headless: cliArgs.headless,
+        chromiumSandbox: cliArgs.sandbox ?? playwrightOpts?.chromiumSandbox,
+        ignoreHTTPSErrors: cliArgs.ignoreHttpsErrors ?? playwrightOpts?.ignoreHTTPSErrors,
+    };
+    /**
+     * Get the default monitor config from synthetics.config.ts file
+     */
+    const monitor = config.monitor;
     if (cliArgs.throttling) {
-        options.networkConditions = (0, helpers_1.parseNetworkConditions)(cliArgs.throttling);
+        const throttleConfig = deepmerge_1.default.all([
+            helpers_1.DEFAULT_THROTTLING_OPTIONS,
+            monitor?.throttling || {},
+            cliArgs.throttling,
+        ]);
+        options.throttling = throttleConfig;
+        options.networkConditions = (0, helpers_1.getNetworkConditions)(throttleConfig);
     }
+    else {
+        /**
+         * Do not apply throttling when `--no-throttling` flag is passed
+         */
+        options.throttling = {};
+    }
+    options.schedule = cliArgs.schedule ?? monitor?.schedule;
+    options.locations = cliArgs.locations ?? monitor?.locations;
     return options;
 }
 exports.normalizeOptions = normalizeOptions;
+/**
+ * Parses the throttling CLI settings and also
+ * adapts to the format to keep the backwards compatability
+ * - Accepts old format `<5d/3u/20l>`
+ * - Processess new format otherwise `{download: 5, upload: 3, latency: 20}`
+ */
+function parseThrottling(value, prev) {
+    const THROTTLING_REGEX = /([0-9]{1,}u)|([0-9]{1,}d)|([0-9]{1,}l)/gm;
+    if (THROTTLING_REGEX.test(value)) {
+        const throttling = {};
+        const conditions = value.split('/');
+        conditions.forEach(condition => {
+            const setting = condition.slice(0, condition.length - 1);
+            const token = condition.slice(-1);
+            switch (token) {
+                case 'd':
+                    throttling.download = Number(setting);
+                    break;
+                case 'u':
+                    throttling.upload = Number(setting);
+                    break;
+                case 'l':
+                    throttling.latency = Number(setting);
+                    break;
+            }
+        });
+        return throttling;
+    }
+    return JSON.parse(value || prev);
+}
+exports.parseThrottling = parseThrottling;
 //# sourceMappingURL=options.js.map

package/dist/options.js.map

@@ -1 +1 @@
-{"version":3,"file":"options.js","sourceRoot":"","sources":["../src/options.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;;;;;;AAEH,0DAA8B;AAC9B,qCAAsC;AACtC,uCAAmD;AAGnD;;;GAGG;AACH,MAAM,SAAS,GAAG,YAAY,CAAC;AAC/B,IAAI,OAAO,CAAC,GAAG,CAAC,KAAK,IAAI,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE;IAC9D,OAAO,CAAC,GAAG,CAAC,KAAK,GAAG,GAAG,CAAC;CACzB;AAED,SAAgB,gBAAgB,CAAC,OAAgB;IAC/C,MAAM,OAAO,GAAe;QAC1B,GAAG,OAAO;QACV,WAAW,EAAE,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,aAAa;KACtD,CAAC;IACF;;;OAGG;IACH,IAAI,OAAO,CAAC,UAAU,EAAE;QACtB,OAAO,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,MAAM,CAAC;QAC9C,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;QACxB,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;QACvB,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;QACrB,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;KAC9B;IAED,IAAI,OAAO,CAAC,UAAU,EAAE;QACtB,MAAM,qBAAqB,GAAG;YAC5B,OAAO;YACP,SAAS;YACT,YAAY;YACZ,SAAS;YACT,UAAU;SACX,CAAC;QACF;;;;;;WAMG;QACH,KAAK,MAAM,IAAI,IAAI,OAAO,CAAC,UAAU,EAAE;YACrC,IAAI,qBAAqB,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;gBACxC,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;aACtB;iBAAM;gBACL,OAAO,CAAC,IAAI,CACV,uBAAuB,IAAI,yCAAyC,qBAAqB,CAAC,IAAI,CAC5F,IAAI,CACL,EAAE,CACJ,CAAC;aACH;SACF;KACF;IAED;;;OAGG;IACH,MAAM,MAAM,GACV,OAAO,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM;QAC/B,CAAC,CAAC,IAAA,mBAAU,EAAC,OAAO,CAAC,WAAW,EAAE,OAAO,CAAC,MAAM,CAAC;QACjD,CAAC,CAAC,EAAE,CAAC;IAET,OAAO,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,IAAA,mBAAK,EAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,CAAC;IAE3E;;OAEG;IACH,OAAO,CAAC,iBAAiB,GAAG,mBAAK,CAAC,GAAG,CAAC;QACpC,MAAM,CAAC,iBAAiB,IAAI,EAAE;QAC9B,OAAO,CAAC,iBAAiB,IAAI,EAAE;QAC/B;YACE,QAAQ,EAAE,OAAO,CAAC,QAAQ;YAC1B,eAAe,EAAE,OAAO,CAAC,OAAO;YAChC,iBAAiB,EAAE,OAAO,CAAC,iBAAiB;SAC7C;KACF,CAAC,CAAC;IAEH,IAAI,OAAO,CAAC,UAAU,EAAE;QACtB,OAAO,CAAC,iBAAiB,GAAG,IAAA,gCAAsB,EAChD,OAAO,CAAC,UAAoB,CAC7B,CAAC;KACH;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AA5ED,4CA4EC"}
+{"version":3,"file":"options.js","sourceRoot":"","sources":["../src/options.ts"],"names":[],"mappings":"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"}

package/dist/plugins/network.d.ts

@@ -22,45 +22,32 @@
  * THE SOFTWARE.
  *
  */
-import { Protocol } from 'playwright-core/types/protocol';
 import { NetworkInfo, Driver } from '../common_types';
 import { Step } from '../dsl';
+/**
+ * Used as a key in each Network Request to identify the
+ * associated request across distinct lifecycle events
+ */
+export declare const NETWORK_ENTRY_SUMBOL: unique symbol;
 export declare class NetworkManager {
     private driver;
     private _browser;
-    private _InflightRequestMap;
+    private _barrierPromises;
     results: Array<NetworkInfo>;
     _currentStep: Partial<Step>;
     constructor(driver: Driver);
-    start(): Promise<void>;
-    _findNetworkRecord(requestId: string): NetworkInfo;
-    _onRequestWillBeSent(event: Protocol.Network.requestWillBeSentPayload): void;
-    _onRequestWillBeSentExtraInfo(event: Protocol.Network.requestWillBeSentExtraInfoPayload): void;
-    _onDataReceived(event: Protocol.Network.dataReceivedPayload): void;
-    _onResponseReceived(event: Protocol.Network.responseReceivedPayload): void;
-    _onLoadingFinished(event: Protocol.Network.loadingFinishedPayload): void;
-    _onLoadingFailed(event: Protocol.Network.loadingFailedPayload): void;
-    _requestCompleted(requestId: string, endTime: number, encodedDataLength?: number): void;
     /**
-     * Account for missing response received event and also adjust the
-     * response received event based on when first byte event was recorded
+     * Adds a protection barrier aganist all asynchronous extract operations from
+     * request/response object that are happening during page lifecycle, If the
+     * page is closed during the extraction, the barrier enforces those operations
+     * to not result in exception
      */
-    stop(): NetworkInfo[];
+    private _addBarrier;
+    start(): Promise<void>;
+    private _findNetworkEntry;
+    private _onRequest;
+    private _onResponse;
+    private _onRequestCompleted;
+    stop(): Promise<NetworkInfo[]>;
 }
-/**
- * The timing calculations are based on the chrome devtools frontend
- * https://github.com/ChromeDevTools/devtools-frontend/blob/7f5478d8ceb7586f23f4073ab5c2085dac1ec26a/front_end/network/RequestTimingView.js#L98-L193
- */
-export declare function calculateTimings(record: NetworkInfo): {
-    blocked: number;
-    queueing: number;
-    dns: number;
-    ssl: number;
-    proxy: number;
-    connect: number;
-    send: number;
-    wait: number;
-    receive: number;
-    total: number;
-};
 //# sourceMappingURL=network.d.ts.map

package/dist/plugins/network.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["../../src/plugins/network.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAe,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACnE,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAG9B,qBAAa,cAAc;IAMb,OAAO,CAAC,MAAM;IAL1B,OAAO,CAAC,QAAQ,CAAc;IAC9B,OAAO,CAAC,mBAAmB,CAAkC;IAC7D,OAAO,EAAE,KAAK,CAAC,WAAW,CAAC,CAAM;IACjC,YAAY,EAAE,OAAO,CAAC,IAAI,CAAC,CAAQ;gBAEf,MAAM,EAAE,MAAM;IAE5B,KAAK;IAuBX,kBAAkB,CAAC,SAAS,EAAE,MAAM;IAIpC,oBAAoB,CAAC,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,wBAAwB;IA+ErE,6BAA6B,CAC3B,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,iCAAiC;IAiB3D,eAAe,CAAC,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,mBAAmB;IAU3D,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,uBAAuB;IAiCnE,kBAAkB,CAAC,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,sBAAsB;IAKjE,gBAAgB,CAAC,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,oBAAoB;IAK7D,iBAAiB,CACf,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,iBAAiB,CAAC,EAAE,MAAM;IAsB5B;;;OAGG;IAEH,IAAI;CAGL;AAoBD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,WAAW;;;;;;;;;;;EA6GnD"}
+{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["../../src/plugins/network.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,EAAE,WAAW,EAAe,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACnE,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAY9B;;;GAGG;AACH,eAAO,MAAM,oBAAoB,eAA6B,CAAC;AAM/D,qBAAa,cAAc;IAMb,OAAO,CAAC,MAAM;IAL1B,OAAO,CAAC,QAAQ,CAAc;IAC9B,OAAO,CAAC,gBAAgB,CAA4B;IACpD,OAAO,EAAE,KAAK,CAAC,WAAW,CAAC,CAAM;IACjC,YAAY,EAAE,OAAO,CAAC,IAAI,CAAC,CAAQ;gBAEf,MAAM,EAAE,MAAM;IAElC;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAeb,KAAK;IAeX,OAAO,CAAC,iBAAiB;IAMzB,OAAO,CAAC,UAAU;YAgDJ,WAAW;YAgDX,mBAAmB;IAoG3B,IAAI;CAUX"}

package/dist/plugins/network.js

@@ -24,300 +24,234 @@
  *
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateTimings = exports.NetworkManager = void 0;
+exports.NetworkManager = exports.NETWORK_ENTRY_SUMBOL = void 0;
 const helpers_1 = require("../helpers");
+/**
+ * Kibana UI expects the requestStartTime and loadEndTime to be baseline
+ * in seconds as they have the logic to convert it to milliseconds before
+ * using for offset calculation
+ */
+function epochTimeInSeconds() {
+    return (0, helpers_1.getTimestamp)() / 1e6;
+}
+/**
+ * Used as a key in each Network Request to identify the
+ * associated request across distinct lifecycle events
+ */
+exports.NETWORK_ENTRY_SUMBOL = Symbol.for('NetworkEntry');
 class NetworkManager {
     constructor(driver) {
         this.driver = driver;
-        this._InflightRequestMap = new Map();
+        this._barrierPromises = new Set();
         this.results = [];
         this._currentStep = null;
     }
+    /**
+     * Adds a protection barrier aganist all asynchronous extract operations from
+     * request/response object that are happening during page lifecycle, If the
+     * page is closed during the extraction, the barrier enforces those operations
+     * to not result in exception
+     */
+    _addBarrier(page, promise) {
+        if (!page)
+            return;
+        const race = Promise.race([
+            new Promise(resolve => page.on('close', () => {
+                this._barrierPromises.delete(race);
+                resolve();
+            })),
+            promise,
+        ]);
+        this._barrierPromises.add(race);
+        race.then(() => this._barrierPromises.delete(race));
+    }
     async start() {
-        const { client } = this.driver;
+        const { client, context } = this.driver;
         const { product } = await client.send('Browser.getVersion');
         const [name, version] = product.split('/');
         this._browser = { name, version };
         await client.send('Network.enable');
         /**
-         * Listen for all network events
+         * Listen for all network events from PW context
          */
-        client.on('Network.requestWillBeSent', this._onRequestWillBeSent.bind(this));
-        client.on('Network.requestWillBeSentExtraInfo', this._onRequestWillBeSentExtraInfo.bind(this));
-        client.on('Network.dataReceived', this._onDataReceived.bind(this));
-        client.on('Network.responseReceived', this._onResponseReceived.bind(this));
-        client.on('Network.loadingFinished', this._onLoadingFinished.bind(this));
-        client.on('Network.loadingFailed', this._onLoadingFailed.bind(this));
+        context.on('request', this._onRequest.bind(this));
+        context.on('response', this._onResponse.bind(this));
+        context.on('requestfinished', this._onRequestCompleted.bind(this));
+        context.on('requestfailed', this._onRequestCompleted.bind(this));
     }
-    _findNetworkRecord(requestId) {
-        return this._InflightRequestMap.get(requestId);
+    _findNetworkEntry(request) {
+        return request[exports.NETWORK_ENTRY_SUMBOL];
     }
-    _onRequestWillBeSent(event) {
-        const { url, method, postData, headers } = event.request;
+    _onRequest(request) {
+        const url = request.url();
         /**
          * Data URI should not show up as network requests
          */
         if (url.startsWith('data:')) {
             return;
         }
-        const { requestId, timestamp, type, loaderId } = event;
-        const isNavigationRequest = requestId == loaderId && type === 'Document';
-        const record = this._findNetworkRecord(requestId);
-        /**
-         * On redirects, another `requestWillBeSent` event will be fired for the
-         * same requestId. We calculate the timings for the redirect request using
-         * the `redirectedResponse` from the redirected request.
-         */
-        if (record) {
-            if (event.redirectResponse) {
-                record.response.redirectURL = url;
-                const response = event.redirectResponse;
-                const data = Object.assign(event, {
-                    type: event.type,
-                    response,
-                    encodedDataLength: response.encodedDataLength,
-                    hasExtraInfo: false,
-                });
-                this._onResponseReceived(data);
-                this._onLoadingFinished(data);
-            }
-            else {
-                /**
-                 * Edge case, we handle it to proceed with next navigation
-                 */
-                this._onLoadingFailed(Object.assign(event, {
-                    type: event.type,
-                    errorText: 'redirectResponse data is not available',
-                }));
-            }
-            const redirectedRecord = this._findNetworkRecord(requestId);
-            /**
-             * Rewrite the map with new redirect id to not reset
-             * the redirect request with original request
-             */
-            this._InflightRequestMap.delete(requestId);
-            this._InflightRequestMap.set(`redirect:${timestamp}:${requestId}`, redirectedRecord);
-        }
-        this._InflightRequestMap.set(requestId, {
+        const timestamp = (0, helpers_1.getTimestamp)();
+        const networkEntry = {
             browser: this._browser,
             step: this._currentStep,
-            timestamp: (0, helpers_1.getTimestamp)(),
+            timestamp,
             url,
-            type,
+            type: request.resourceType(),
             request: {
                 url,
-                method,
-                headers,
-                bytes: postData?.length || 0,
+                method: request.method(),
+                headers: {},
+                body: {
+                    bytes: request.postDataBuffer()?.length || 0,
+                },
             },
             response: {
                 status: -1,
-                mimeType: 'x-unknown',
                 headers: {},
-                timing: null,
+                mimeType: 'x-unknown',
+                redirectURL: '',
             },
-            isNavigationRequest,
-            requestSentTime: timestamp,
-            responseReceivedTime: -1,
+            isNavigationRequest: request.isNavigationRequest(),
+            requestSentTime: epochTimeInSeconds(),
             loadEndTime: -1,
+            responseReceivedTime: -1,
             resourceSize: 0,
             transferSize: 0,
             timings: null,
-        });
+        };
+        if (request.redirectedFrom()) {
+            const fromEntry = this._findNetworkEntry(request.redirectedFrom());
+            if (fromEntry)
+                fromEntry.response.redirectURL = request.url();
+        }
+        request[exports.NETWORK_ENTRY_SUMBOL] = networkEntry;
+        this.results.push(networkEntry);
     }
-    _onRequestWillBeSentExtraInfo(event) {
-        const { requestId, headers } = event;
-        const record = this._findNetworkRecord(requestId);
-        if (!record) {
+    async _onResponse(response) {
+        const request = response.request();
+        const networkEntry = this._findNetworkEntry(request);
+        if (!networkEntry)
             return;
-        }
-        /**
-         * Enhance request headers with additional information
-         */
-        record.request.headers = {
-            ...record.request.headers,
-            ...headers,
+        networkEntry.responseReceivedTime = epochTimeInSeconds();
+        networkEntry.response = {
+            url: response.url(),
+            status: response.status(),
+            statusText: response.statusText(),
+            headers: {},
+            mimeType: 'x-unknown',
+            redirectURL: networkEntry.response.redirectURL,
         };
-        record.request.referrer = record.request.headers?.Referer;
+        const page = request.frame().page();
+        this._addBarrier(page, request.allHeaders().then(reqHeaders => {
+            networkEntry.request.headers = reqHeaders;
+            networkEntry.request.referrer = reqHeaders?.referer;
+        }));
+        this._addBarrier(page, response.serverAddr().then(server => {
+            networkEntry.response.remoteIPAddress = server?.ipAddress;
+            networkEntry.response.remotePort = server?.port;
+        }));
+        this._addBarrier(page, response.securityDetails().then(details => {
+            if (details)
+                networkEntry.response.securityDetails = details;
+        }));
+        this._addBarrier(page, response.allHeaders().then(resHeaders => {
+            networkEntry.response.headers = resHeaders;
+            const contentType = resHeaders['content-type'];
+            if (contentType)
+                networkEntry.response.mimeType = contentType.split(';')[0];
+        }));
     }
-    _onDataReceived(event) {
-        const { requestId, dataLength, encodedDataLength } = event;
-        const record = this._findNetworkRecord(requestId);
-        if (!record) {
+    async _onRequestCompleted(request) {
+        const networkEntry = this._findNetworkEntry(request);
+        if (!networkEntry)
             return;
-        }
-        record.resourceSize += dataLength;
-        if (encodedDataLength >= 0)
-            record.transferSize += encodedDataLength;
-    }
-    _onResponseReceived(event) {
-        const { requestId, response, timestamp } = event;
-        const record = this._findNetworkRecord(requestId);
-        if (!record) {
+        networkEntry.loadEndTime = epochTimeInSeconds();
+        const timing = request.timing();
+        const { loadEndTime, requestSentTime } = networkEntry;
+        networkEntry.timings = {
+            blocked: -1,
+            dns: -1,
+            ssl: -1,
+            connect: -1,
+            send: -1,
+            wait: -1,
+            receive: -1,
+            total: -1,
+        };
+        const firstPositive = (numbers) => {
+            for (let i = 0; i < numbers.length; ++i) {
+                if (numbers[i] > 0) {
+                    return numbers[i];
+                }
+            }
+            return null;
+        };
+        const roundMilliSecs = (value) => {
+            return Math.floor(value * 1000) / 1000;
+        };
+        if (timing.startTime === 0) {
+            // Convert to milliseconds before round off
+            const total = roundMilliSecs((loadEndTime - requestSentTime) * 1000);
+            networkEntry.timings.total = total;
             return;
         }
-        record.responseReceivedTime = timestamp;
-        record.transferSize = response.encodedDataLength;
-        record.response = {
-            url: response.url,
-            status: response.status,
-            protocol: response.protocol,
-            statusText: response.statusText,
-            headers: response.headers,
-            mimeType: response.mimeType,
-            remoteIPAddress: response.remoteIPAddress,
-            remotePort: response.remotePort,
-            fromServiceWorker: response.fromServiceWorker,
-            redirectURL: record.response.redirectURL,
-            timing: response.timing,
+        const blocked = roundMilliSecs(firstPositive([
+            timing.domainLookupStart,
+            timing.connectStart,
+            timing.requestStart,
+        ])) || -1;
+        const dns = timing.domainLookupEnd !== -1
+            ? roundMilliSecs(timing.domainLookupEnd - timing.domainLookupStart)
+            : -1;
+        const connect = timing.connectEnd !== -1
+            ? roundMilliSecs(timing.connectEnd - timing.connectStart)
+            : -1;
+        const ssl = timing.secureConnectionStart !== -1
+            ? roundMilliSecs(timing.connectEnd - timing.secureConnectionStart)
+            : -1;
+        const wait = timing.responseStart !== -1
+            ? roundMilliSecs(timing.responseStart - timing.requestStart)
+            : -1;
+        const receive = timing.responseEnd !== -1
+            ? roundMilliSecs(timing.responseEnd - timing.responseStart)
+            : -1;
+        const total = [blocked, dns, connect, wait, receive].reduce((pre, cur) => (cur > 0 ? cur + pre : pre), 0);
+        networkEntry.timings = {
+            blocked,
+            dns,
+            connect,
+            ssl,
+            wait,
+            send: 0,
+            receive,
+            total,
         };
-        if (response.securityDetails) {
-            record.response.securityDetails = {
-                protocol: response.securityDetails.protocol,
-                subjectName: response.securityDetails.subjectName,
-                issuer: response.securityDetails.issuer,
-                validFrom: response.securityDetails.validFrom,
-                validTo: response.securityDetails.validTo,
+        const page = request.frame().page();
+        // For aborted/failed requests sizes will not be present
+        this._addBarrier(page, request.sizes().then(sizes => {
+            networkEntry.request.bytes =
+                sizes.requestHeadersSize + sizes.requestBodySize;
+            networkEntry.request.body = {
+                bytes: sizes.requestBodySize,
             };
-        }
-    }
-    _onLoadingFinished(event) {
-        const { requestId, timestamp, encodedDataLength } = event;
-        this._requestCompleted(requestId, timestamp, encodedDataLength);
-    }
-    _onLoadingFailed(event) {
-        const { requestId, timestamp } = event;
-        this._requestCompleted(requestId, timestamp);
-    }
-    _requestCompleted(requestId, endTime, encodedDataLength) {
-        const record = this._findNetworkRecord(requestId);
-        if (!record) {
-            return;
-        }
-        if (encodedDataLength >= 0) {
-            record.transferSize = encodedDataLength;
-            record.response.body = {
-                bytes: encodedDataLength,
+            networkEntry.response.bytes =
+                sizes.responseHeadersSize + sizes.responseBodySize;
+            networkEntry.response.body = {
+                bytes: sizes.responseBodySize,
             };
-        }
-        record.loadEndTime = endTime;
-        record.timings = calculateTimings(record);
-        this.results.push(record);
-        /**
-         * When there is DNS failure, browsers keeps retrying requests which
-         * might result in incorrect timings so we get remove them to measure only once
-         */
-        this._InflightRequestMap.delete(requestId);
+            networkEntry.transferSize = sizes.responseBodySize;
+        }));
     }
-    /**
-     * Account for missing response received event and also adjust the
-     * response received event based on when first byte event was recorded
-     */
-    stop() {
+    async stop() {
+        await Promise.all(this._barrierPromises);
+        const context = this.driver.context;
+        context.off('request', this._onRequest.bind(this));
+        context.off('response', this._onResponse.bind(this));
+        context.off('requestfinished', this._onRequestCompleted.bind(this));
+        context.off('requestfailed', this._onRequestCompleted.bind(this));
+        this._barrierPromises.clear();
         return this.results;
     }
 }
 exports.NetworkManager = NetworkManager;
-function getResponseReceivedTime(timing, responseReceivedTime) {
-    if (timing == null) {
-        return responseReceivedTime;
-    }
-    const startTime = timing.requestTime;
-    const headersReceivedTime = startTime + timing.receiveHeadersEnd / 1000;
-    if (responseReceivedTime < 0 || responseReceivedTime > headersReceivedTime) {
-        responseReceivedTime = headersReceivedTime;
-    }
-    if (startTime > responseReceivedTime) {
-        responseReceivedTime = startTime;
-    }
-    return responseReceivedTime;
-}
-/**
- * The timing calculations are based on the chrome devtools frontend
- * https://github.com/ChromeDevTools/devtools-frontend/blob/7f5478d8ceb7586f23f4073ab5c2085dac1ec26a/front_end/network/RequestTimingView.js#L98-L193
- */
-function calculateTimings(record) {
-    const result = {
-        blocked: -1,
-        queueing: -1,
-        proxy: -1,
-        dns: -1,
-        ssl: -1,
-        connect: -1,
-        send: -1,
-        wait: -1,
-        receive: -1,
-        total: -1,
-    };
-    const toMilliseconds = (time) => (time === -1 ? -1 : time * 1000);
-    const calculateDiffInMs = (name, start, end) => {
-        if (start < Number.MAX_VALUE && start <= end) {
-            result[name] = toMilliseconds(end - start);
-        }
-    };
-    const firstPositive = (numbers) => {
-        for (let i = 0; i < numbers.length; ++i) {
-            if (numbers[i] > 0) {
-                return numbers[i];
-            }
-        }
-        return null;
-    };
-    /**
-     * requestTime is baseline in seconds, rest of the timing data are ticks in milliseconds
-     * from the requestTime, so we calculate the offset from that
-     */
-    const addOffsetRange = (name, start, end) => {
-        if (start >= 0 && end >= 0) {
-            calculateDiffInMs(name, startTime + start / 1000, startTime + end / 1000);
-        }
-    };
-    const { requestSentTime, loadEndTime, responseReceivedTime, response } = record;
-    const timing = response.timing;
-    const actResRcvdTime = getResponseReceivedTime(timing, responseReceivedTime);
-    const issueTime = requestSentTime;
-    const startTime = timing == null ? -1 : timing.requestTime;
-    const endTime = firstPositive([loadEndTime, actResRcvdTime]) || startTime;
-    if (timing == null) {
-        const start = issueTime !== -1 ? issueTime : startTime !== -1 ? startTime : 0;
-        const middle = actResRcvdTime === -1 ? Number.MAX_VALUE : actResRcvdTime;
-        const end = endTime === -1 ? Number.MAX_VALUE : endTime;
-        calculateDiffInMs('total', start, end);
-        calculateDiffInMs('blocked', start, middle);
-        calculateDiffInMs('receive', middle, end);
-        // Check if the request is blocked/stalled for the whole timeframe and
-        // calculate timings appropriately for that request
-        if (!isFinite(result['blocked'])) {
-            result['blocked'] = result['total'];
-        }
-        return result;
-    }
-    calculateDiffInMs('total', issueTime < startTime ? issueTime : startTime, endTime);
-    if (issueTime < startTime) {
-        calculateDiffInMs('queueing', issueTime, startTime);
-    }
-    const responseReceived = toMilliseconds(actResRcvdTime - startTime);
-    if (response.fromServiceWorker) {
-        addOffsetRange('blocked', 0, timing.workerStart);
-        addOffsetRange('wait', timing.sendEnd, responseReceived);
-    }
-    else if (!timing.pushStart) {
-        const blockingEnd = firstPositive([
-            timing.dnsStart,
-            timing.connectStart,
-            timing.sendStart,
-            responseReceived,
-        ]) || 0;
-        addOffsetRange('blocked', 0, blockingEnd);
-        addOffsetRange('proxy', timing.proxyStart, timing.proxyEnd);
-        addOffsetRange('dns', timing.dnsStart, timing.dnsEnd);
-        addOffsetRange('connect', timing.connectStart, timing.connectEnd);
-        addOffsetRange('ssl', timing.sslStart, timing.sslEnd);
-        addOffsetRange('send', timing.sendStart, timing.sendEnd);
-        addOffsetRange('wait', Math.max(timing.sendEnd, timing.connectEnd, timing.dnsEnd, timing.proxyEnd, blockingEnd), responseReceived);
-    }
-    calculateDiffInMs('receive', actResRcvdTime, endTime);
-    return result;
-}
-exports.calculateTimings = calculateTimings;
 //# sourceMappingURL=network.js.map