@paulirish/trace_engine 0.0.25 → 0.0.27

package/models/trace/lantern/simulation/ConnectionPool.d.ts

@@ -0,0 +1,26 @@
+import type * as Lantern from '../types/types.js';
+import { TCPConnection } from './TCPConnection.js';
+export declare class ConnectionPool {
+    _options: Required<Lantern.Simulation.Options>;
+    _records: Lantern.NetworkRequest[];
+    _connectionsByOrigin: Map<string, TCPConnection[]>;
+    _connectionsByRequest: Map<Lantern.NetworkRequest, TCPConnection>;
+    _connectionsInUse: Set<TCPConnection>;
+    _connectionReusedByRequestId: Map<string, boolean>;
+    constructor(records: Lantern.NetworkRequest[], options: Required<Lantern.Simulation.Options>);
+    connectionsInUse(): TCPConnection[];
+    _initializeConnections(): void;
+    _findAvailableConnectionWithLargestCongestionWindow(connections: TCPConnection[]): TCPConnection | null;
+    /**
+     * This method finds an available connection to the origin specified by the network request or null
+     * if no connection was available. If returned, connection will not be available for other network
+     * records until release is called.
+     */
+    acquire(request: Lantern.NetworkRequest): TCPConnection | null;
+    /**
+     * Return the connection currently being used to fetch a request. If no connection
+     * currently being used for this request, an error will be thrown.
+     */
+    acquireActiveConnectionFromRequest(request: Lantern.NetworkRequest): TCPConnection;
+    release(request: Lantern.NetworkRequest): void;
+}

package/models/trace/lantern/simulation/ConnectionPool.js

@@ -0,0 +1,116 @@
+// Copyright 2024 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as Core from '../core/core.js';
+import { TCPConnection } from './TCPConnection.js';
+const DEFAULT_SERVER_RESPONSE_TIME = 30;
+const TLS_SCHEMES = ['https', 'wss'];
+// Each origin can have 6 simulatenous connections open
+// https://cs.chromium.org/chromium/src/net/socket/client_socket_pool_manager.cc?type=cs&q="int+g_max_sockets_per_group"
+const CONNECTIONS_PER_ORIGIN = 6;
+export class ConnectionPool {
+    _options;
+    _records;
+    _connectionsByOrigin;
+    _connectionsByRequest;
+    _connectionsInUse;
+    _connectionReusedByRequestId;
+    constructor(records, options) {
+        this._options = options;
+        this._records = records;
+        this._connectionsByOrigin = new Map();
+        this._connectionsByRequest = new Map();
+        this._connectionsInUse = new Set();
+        this._connectionReusedByRequestId = Core.NetworkAnalyzer.estimateIfConnectionWasReused(records, {
+            forceCoarseEstimates: true,
+        });
+        this._initializeConnections();
+    }
+    connectionsInUse() {
+        return Array.from(this._connectionsInUse);
+    }
+    _initializeConnections() {
+        const connectionReused = this._connectionReusedByRequestId;
+        const additionalRttByOrigin = this._options.additionalRttByOrigin;
+        const serverResponseTimeByOrigin = this._options.serverResponseTimeByOrigin;
+        const recordsByOrigin = Core.NetworkAnalyzer.groupByOrigin(this._records);
+        for (const [origin, requests] of recordsByOrigin.entries()) {
+            const connections = [];
+            const additionalRtt = additionalRttByOrigin.get(origin) || 0;
+            const responseTime = serverResponseTimeByOrigin.get(origin) || DEFAULT_SERVER_RESPONSE_TIME;
+            for (const request of requests) {
+                if (connectionReused.get(request.requestId)) {
+                    continue;
+                }
+                const isTLS = TLS_SCHEMES.includes(request.parsedURL.scheme);
+                const isH2 = request.protocol === 'h2';
+                const connection = new TCPConnection(this._options.rtt + additionalRtt, this._options.throughput, responseTime, isTLS, isH2);
+                connections.push(connection);
+            }
+            if (!connections.length) {
+                throw new Error(`Could not find a connection for origin: ${origin}`);
+            }
+            // Make sure each origin has minimum number of connections available for max throughput.
+            // But only if it's not over H2 which maximizes throughput already.
+            const minConnections = connections[0].isH2() ? 1 : CONNECTIONS_PER_ORIGIN;
+            while (connections.length < minConnections) {
+                connections.push(connections[0].clone());
+            }
+            this._connectionsByOrigin.set(origin, connections);
+        }
+    }
+    _findAvailableConnectionWithLargestCongestionWindow(connections) {
+        let maxConnection = null;
+        for (let i = 0; i < connections.length; i++) {
+            const connection = connections[i];
+            // Connections that are in use are never available.
+            if (this._connectionsInUse.has(connection)) {
+                continue;
+            }
+            // This connection is a match and is available! Update our max if it has a larger congestionWindow
+            const currentMax = (maxConnection?.congestionWindow) || -Infinity;
+            if (connection.congestionWindow > currentMax) {
+                maxConnection = connection;
+            }
+        }
+        return maxConnection;
+    }
+    /**
+     * This method finds an available connection to the origin specified by the network request or null
+     * if no connection was available. If returned, connection will not be available for other network
+     * records until release is called.
+     */
+    acquire(request) {
+        if (this._connectionsByRequest.has(request)) {
+            throw new Error('Record already has a connection');
+        }
+        const origin = request.parsedURL.securityOrigin;
+        const connections = this._connectionsByOrigin.get(origin) || [];
+        const connectionToUse = this._findAvailableConnectionWithLargestCongestionWindow(connections);
+        if (!connectionToUse) {
+            return null;
+        }
+        this._connectionsInUse.add(connectionToUse);
+        this._connectionsByRequest.set(request, connectionToUse);
+        return connectionToUse;
+    }
+    /**
+     * Return the connection currently being used to fetch a request. If no connection
+     * currently being used for this request, an error will be thrown.
+     */
+    acquireActiveConnectionFromRequest(request) {
+        const activeConnection = this._connectionsByRequest.get(request);
+        if (!activeConnection) {
+            throw new Error('Could not find an active connection for request');
+        }
+        return activeConnection;
+    }
+    release(request) {
+        const connection = this._connectionsByRequest.get(request);
+        this._connectionsByRequest.delete(request);
+        if (connection) {
+            this._connectionsInUse.delete(connection);
+        }
+    }
+}
+//# sourceMappingURL=ConnectionPool.js.map

package/models/trace/lantern/simulation/ConnectionPool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConnectionPool.js","sourceRoot":"","sources":["../../../../../../../../front_end/models/trace/lantern/simulation/ConnectionPool.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2024 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\n\nimport * as Core from '../core/core.js';\nimport type * as Lantern from '../types/types.js';\n\nimport {TCPConnection} from './TCPConnection.js';\n\nconst DEFAULT_SERVER_RESPONSE_TIME = 30;\nconst TLS_SCHEMES = ['https', 'wss'];\n\n// Each origin can have 6 simulatenous connections open\n// https://cs.chromium.org/chromium/src/net/socket/client_socket_pool_manager.cc?type=cs&q=\"int+g_max_sockets_per_group\"\nconst CONNECTIONS_PER_ORIGIN = 6;\n\nexport class ConnectionPool {\n  _options: Required<Lantern.Simulation.Options>;\n  _records: Lantern.NetworkRequest[];\n  _connectionsByOrigin: Map<string, TCPConnection[]>;\n  _connectionsByRequest: Map<Lantern.NetworkRequest, TCPConnection>;\n  _connectionsInUse: Set<TCPConnection>;\n  _connectionReusedByRequestId: Map<string, boolean>;\n\n  constructor(records: Lantern.NetworkRequest[], options: Required<Lantern.Simulation.Options>) {\n    this._options = options;\n\n    this._records = records;\n    this._connectionsByOrigin = new Map();\n    this._connectionsByRequest = new Map();\n    this._connectionsInUse = new Set();\n    this._connectionReusedByRequestId = Core.NetworkAnalyzer.estimateIfConnectionWasReused(records, {\n      forceCoarseEstimates: true,\n    });\n\n    this._initializeConnections();\n  }\n\n  connectionsInUse(): TCPConnection[] {\n    return Array.from(this._connectionsInUse);\n  }\n\n  _initializeConnections(): void {\n    const connectionReused = this._connectionReusedByRequestId;\n    const additionalRttByOrigin = this._options.additionalRttByOrigin;\n    const serverResponseTimeByOrigin = this._options.serverResponseTimeByOrigin;\n\n    const recordsByOrigin = Core.NetworkAnalyzer.groupByOrigin(this._records);\n    for (const [origin, requests] of recordsByOrigin.entries()) {\n      const connections = [];\n      const additionalRtt = additionalRttByOrigin.get(origin) || 0;\n      const responseTime = serverResponseTimeByOrigin.get(origin) || DEFAULT_SERVER_RESPONSE_TIME;\n\n      for (const request of requests) {\n        if (connectionReused.get(request.requestId)) {\n          continue;\n        }\n\n        const isTLS = TLS_SCHEMES.includes(request.parsedURL.scheme);\n        const isH2 = request.protocol === 'h2';\n        const connection = new TCPConnection(\n            this._options.rtt + additionalRtt,\n            this._options.throughput,\n            responseTime,\n            isTLS,\n            isH2,\n        );\n\n        connections.push(connection);\n      }\n\n      if (!connections.length) {\n        throw new Error(`Could not find a connection for origin: ${origin}`);\n      }\n\n      // Make sure each origin has minimum number of connections available for max throughput.\n      // But only if it's not over H2 which maximizes throughput already.\n      const minConnections = connections[0].isH2() ? 1 : CONNECTIONS_PER_ORIGIN;\n      while (connections.length < minConnections) {\n        connections.push(connections[0].clone());\n      }\n\n      this._connectionsByOrigin.set(origin, connections);\n    }\n  }\n\n  _findAvailableConnectionWithLargestCongestionWindow(connections: TCPConnection[]): TCPConnection|null {\n    let maxConnection: TCPConnection|null = null;\n    for (let i = 0; i < connections.length; i++) {\n      const connection = connections[i];\n\n      // Connections that are in use are never available.\n      if (this._connectionsInUse.has(connection)) {\n        continue;\n      }\n\n      // This connection is a match and is available! Update our max if it has a larger congestionWindow\n      const currentMax = (maxConnection?.congestionWindow) || -Infinity;\n      if (connection.congestionWindow > currentMax) {\n        maxConnection = connection;\n      }\n    }\n\n    return maxConnection;\n  }\n\n  /**\n   * This method finds an available connection to the origin specified by the network request or null\n   * if no connection was available. If returned, connection will not be available for other network\n   * records until release is called.\n   */\n  acquire(request: Lantern.NetworkRequest): TCPConnection|null {\n    if (this._connectionsByRequest.has(request)) {\n      throw new Error('Record already has a connection');\n    }\n\n    const origin = request.parsedURL.securityOrigin;\n    const connections = this._connectionsByOrigin.get(origin) || [];\n    const connectionToUse = this._findAvailableConnectionWithLargestCongestionWindow(connections);\n\n    if (!connectionToUse) {\n      return null;\n    }\n\n    this._connectionsInUse.add(connectionToUse);\n    this._connectionsByRequest.set(request, connectionToUse);\n    return connectionToUse;\n  }\n\n  /**\n   * Return the connection currently being used to fetch a request. If no connection\n   * currently being used for this request, an error will be thrown.\n   */\n  acquireActiveConnectionFromRequest(request: Lantern.NetworkRequest): TCPConnection {\n    const activeConnection = this._connectionsByRequest.get(request);\n    if (!activeConnection) {\n      throw new Error('Could not find an active connection for request');\n    }\n\n    return activeConnection;\n  }\n\n  release(request: Lantern.NetworkRequest): void {\n    const connection = this._connectionsByRequest.get(request);\n    this._connectionsByRequest.delete(request);\n    if (connection) {\n      this._connectionsInUse.delete(connection);\n    }\n  }\n}\n"]}

package/models/trace/lantern/simulation/Constants.d.ts

@@ -0,0 +1,31 @@
+declare const Constants: {
+    throttling: {
+        DEVTOOLS_RTT_ADJUSTMENT_FACTOR: number;
+        DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR: number;
+        mobileSlow4G: {
+            rttMs: number;
+            throughputKbps: number;
+            requestLatencyMs: number;
+            downloadThroughputKbps: number;
+            uploadThroughputKbps: number;
+            cpuSlowdownMultiplier: number;
+        };
+        mobileRegular3G: {
+            rttMs: number;
+            throughputKbps: number;
+            requestLatencyMs: number;
+            downloadThroughputKbps: number;
+            uploadThroughputKbps: number;
+            cpuSlowdownMultiplier: number;
+        };
+        desktopDense4G: {
+            rttMs: number;
+            throughputKbps: number;
+            cpuSlowdownMultiplier: number;
+            requestLatencyMs: number;
+            downloadThroughputKbps: number;
+            uploadThroughputKbps: number;
+        };
+    };
+};
+export { Constants };

package/models/trace/lantern/simulation/Constants.js

@@ -0,0 +1,43 @@
+// Copyright 2024 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+const DEVTOOLS_RTT_ADJUSTMENT_FACTOR = 3.75;
+const DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR = 0.9;
+const throttling = {
+    DEVTOOLS_RTT_ADJUSTMENT_FACTOR,
+    DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,
+    // These values align with WebPageTest's definition of "Fast 3G"
+    // But offer similar characteristics to roughly the 75th percentile of 4G connections.
+    mobileSlow4G: {
+        rttMs: 150,
+        throughputKbps: 1.6 * 1024,
+        requestLatencyMs: 150 * DEVTOOLS_RTT_ADJUSTMENT_FACTOR,
+        downloadThroughputKbps: 1.6 * 1024 * DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,
+        uploadThroughputKbps: 750 * DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,
+        cpuSlowdownMultiplier: 4,
+    },
+    // These values partially align with WebPageTest's definition of "Regular 3G".
+    // These values are meant to roughly align with Chrome UX report's 3G definition which are based
+    // on HTTP RTT of 300-1400ms and downlink throughput of <700kbps.
+    mobileRegular3G: {
+        rttMs: 300,
+        throughputKbps: 700,
+        requestLatencyMs: 300 * DEVTOOLS_RTT_ADJUSTMENT_FACTOR,
+        downloadThroughputKbps: 700 * DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,
+        uploadThroughputKbps: 700 * DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,
+        cpuSlowdownMultiplier: 4,
+    },
+    // Using a "broadband" connection type
+    // Corresponds to "Dense 4G 25th percentile" in https://docs.google.com/document/d/1Ft1Bnq9-t4jK5egLSOc28IL4TvR-Tt0se_1faTA4KTY/edit#heading=h.bb7nfy2x9e5v
+    desktopDense4G: {
+        rttMs: 40,
+        throughputKbps: 10 * 1024,
+        cpuSlowdownMultiplier: 1,
+        requestLatencyMs: 0, // 0 means unset
+        downloadThroughputKbps: 0,
+        uploadThroughputKbps: 0,
+    },
+};
+const Constants = { throttling };
+export { Constants };
+//# sourceMappingURL=Constants.js.map

package/models/trace/lantern/simulation/Constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Constants.js","sourceRoot":"","sources":["../../../../../../../../front_end/models/trace/lantern/simulation/Constants.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAC5D,yEAAyE;AACzE,6BAA6B;AAE7B,MAAM,8BAA8B,GAAG,IAAI,CAAC;AAC5C,MAAM,qCAAqC,GAAG,GAAG,CAAC;AAElD,MAAM,UAAU,GAAG;IACjB,8BAA8B;IAC9B,qCAAqC;IACrC,gEAAgE;IAChE,sFAAsF;IACtF,YAAY,EAAE;QACZ,KAAK,EAAE,GAAG;QACV,cAAc,EAAE,GAAG,GAAG,IAAI;QAC1B,gBAAgB,EAAE,GAAG,GAAG,8BAA8B;QACtD,sBAAsB,EAAE,GAAG,GAAG,IAAI,GAAG,qCAAqC;QAC1E,oBAAoB,EAAE,GAAG,GAAG,qCAAqC;QACjE,qBAAqB,EAAE,CAAC;KACzB;IACD,8EAA8E;IAC9E,gGAAgG;IAChG,iEAAiE;IACjE,eAAe,EAAE;QACf,KAAK,EAAE,GAAG;QACV,cAAc,EAAE,GAAG;QACnB,gBAAgB,EAAE,GAAG,GAAG,8BAA8B;QACtD,sBAAsB,EAAE,GAAG,GAAG,qCAAqC;QACnE,oBAAoB,EAAE,GAAG,GAAG,qCAAqC;QACjE,qBAAqB,EAAE,CAAC;KACzB;IACD,sCAAsC;IACtC,2JAA2J;IAC3J,cAAc,EAAE;QACd,KAAK,EAAE,EAAE;QACT,cAAc,EAAE,EAAE,GAAG,IAAI;QACzB,qBAAqB,EAAE,CAAC;QACxB,gBAAgB,EAAE,CAAC,EAAG,gBAAgB;QACtC,sBAAsB,EAAE,CAAC;QACzB,oBAAoB,EAAE,CAAC;KACxB;CACF,CAAC;AAEF,MAAM,SAAS,GAAG,EAAC,UAAU,EAAC,CAAC;AAE/B,OAAO,EAAC,SAAS,EAAC,CAAC","sourcesContent":["// Copyright 2024 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\n\nconst DEVTOOLS_RTT_ADJUSTMENT_FACTOR = 3.75;\nconst DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR = 0.9;\n\nconst throttling = {\n  DEVTOOLS_RTT_ADJUSTMENT_FACTOR,\n  DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,\n  // These values align with WebPageTest's definition of \"Fast 3G\"\n  // But offer similar characteristics to roughly the 75th percentile of 4G connections.\n  mobileSlow4G: {\n    rttMs: 150,\n    throughputKbps: 1.6 * 1024,\n    requestLatencyMs: 150 * DEVTOOLS_RTT_ADJUSTMENT_FACTOR,\n    downloadThroughputKbps: 1.6 * 1024 * DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,\n    uploadThroughputKbps: 750 * DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,\n    cpuSlowdownMultiplier: 4,\n  },\n  // These values partially align with WebPageTest's definition of \"Regular 3G\".\n  // These values are meant to roughly align with Chrome UX report's 3G definition which are based\n  // on HTTP RTT of 300-1400ms and downlink throughput of <700kbps.\n  mobileRegular3G: {\n    rttMs: 300,\n    throughputKbps: 700,\n    requestLatencyMs: 300 * DEVTOOLS_RTT_ADJUSTMENT_FACTOR,\n    downloadThroughputKbps: 700 * DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,\n    uploadThroughputKbps: 700 * DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,\n    cpuSlowdownMultiplier: 4,\n  },\n  // Using a \"broadband\" connection type\n  // Corresponds to \"Dense 4G 25th percentile\" in https://docs.google.com/document/d/1Ft1Bnq9-t4jK5egLSOc28IL4TvR-Tt0se_1faTA4KTY/edit#heading=h.bb7nfy2x9e5v\n  desktopDense4G: {\n    rttMs: 40,\n    throughputKbps: 10 * 1024,\n    cpuSlowdownMultiplier: 1,\n    requestLatencyMs: 0,  // 0 means unset\n    downloadThroughputKbps: 0,\n    uploadThroughputKbps: 0,\n  },\n};\n\nconst Constants = {throttling};\n\nexport {Constants};\n"]}

package/models/trace/lantern/simulation/DNSCache.d.ts

@@ -0,0 +1,22 @@
+import type * as Lantern from '../types/types.js';
+declare class DNSCache {
+    static rttMultiplier: number;
+    _rtt: number;
+    _resolvedDomainNames: Map<string, {
+        resolvedAt: number;
+    }>;
+    constructor({ rtt }: {
+        rtt: number;
+    });
+    getTimeUntilResolution(request: Lantern.NetworkRequest, options?: {
+        requestedAt: number;
+        shouldUpdateCache: boolean;
+    }): number;
+    _updateCacheResolvedAtIfNeeded(request: Lantern.NetworkRequest, resolvedAt: number): void;
+    /**
+     * Forcefully sets the DNS resolution time for a request.
+     * Useful for testing and alternate execution simulations.
+     */
+    setResolvedAt(domain: string, resolvedAt: number): void;
+}
+export { DNSCache };

package/models/trace/lantern/simulation/DNSCache.js

@@ -0,0 +1,48 @@
+// Copyright 2024 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+// A DNS lookup will usually take ~1-2 roundtrips of connection latency plus the extra DNS routing time.
+// Example: https://www.webpagetest.org/result/180703_3A_e33ec79747c002ed4d7bcbfc81462203/1/details/#waterfall_view_step1
+// Example: https://www.webpagetest.org/result/180707_1M_89673eb633b5d98386de95dfcf9b33d5/1/details/#waterfall_view_step1
+// DNS is highly variable though, many times it's a little more than 1, but can easily be 4-5x RTT.
+// We'll use 2 since it seems to give the most accurate results on average, but this can be tweaked.
+const DNS_RESOLUTION_RTT_MULTIPLIER = 2;
+class DNSCache {
+    static rttMultiplier = DNS_RESOLUTION_RTT_MULTIPLIER;
+    _rtt;
+    _resolvedDomainNames;
+    constructor({ rtt }) {
+        this._rtt = rtt;
+        this._resolvedDomainNames = new Map();
+    }
+    getTimeUntilResolution(request, options) {
+        const { requestedAt = 0, shouldUpdateCache = false } = options || {};
+        const domain = request.parsedURL.host;
+        const cacheEntry = this._resolvedDomainNames.get(domain);
+        let timeUntilResolved = this._rtt * DNSCache.rttMultiplier;
+        if (cacheEntry) {
+            const timeUntilCachedIsResolved = Math.max(cacheEntry.resolvedAt - requestedAt, 0);
+            timeUntilResolved = Math.min(timeUntilCachedIsResolved, timeUntilResolved);
+        }
+        const resolvedAt = requestedAt + timeUntilResolved;
+        if (shouldUpdateCache) {
+            this._updateCacheResolvedAtIfNeeded(request, resolvedAt);
+        }
+        return timeUntilResolved;
+    }
+    _updateCacheResolvedAtIfNeeded(request, resolvedAt) {
+        const domain = request.parsedURL.host;
+        const cacheEntry = this._resolvedDomainNames.get(domain) || { resolvedAt };
+        cacheEntry.resolvedAt = Math.min(cacheEntry.resolvedAt, resolvedAt);
+        this._resolvedDomainNames.set(domain, cacheEntry);
+    }
+    /**
+     * Forcefully sets the DNS resolution time for a request.
+     * Useful for testing and alternate execution simulations.
+     */
+    setResolvedAt(domain, resolvedAt) {
+        this._resolvedDomainNames.set(domain, { resolvedAt });
+    }
+}
+export { DNSCache };
+//# sourceMappingURL=DNSCache.js.map

package/models/trace/lantern/simulation/DNSCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DNSCache.js","sourceRoot":"","sources":["../../../../../../../../front_end/models/trace/lantern/simulation/DNSCache.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAC5D,yEAAyE;AACzE,6BAA6B;AAI7B,wGAAwG;AACxG,yHAAyH;AACzH,yHAAyH;AACzH,mGAAmG;AACnG,oGAAoG;AACpG,MAAM,6BAA6B,GAAG,CAAC,CAAC;AAExC,MAAM,QAAQ;IACZ,MAAM,CAAC,aAAa,GAAG,6BAA6B,CAAC;IAErD,IAAI,CAAS;IACb,oBAAoB,CAAoC;IAExD,YAAY,EAAC,GAAG,EAAgB;QAC9B,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC;QAChB,IAAI,CAAC,oBAAoB,GAAG,IAAI,GAAG,EAAE,CAAC;IACxC,CAAC;IAED,sBAAsB,CAAC,OAA+B,EAAE,OAA2D;QAEjH,MAAM,EAAC,WAAW,GAAG,CAAC,EAAE,iBAAiB,GAAG,KAAK,EAAC,GAAG,OAAO,IAAI,EAAE,CAAC;QAEnE,MAAM,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC;QACtC,MAAM,UAAU,GAAG,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACzD,IAAI,iBAAiB,GAAG,IAAI,CAAC,IAAI,GAAG,QAAQ,CAAC,aAAa,CAAC;QAC3D,IAAI,UAAU,EAAE,CAAC;YACf,MAAM,yBAAyB,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,UAAU,GAAG,WAAW,EAAE,CAAC,CAAC,CAAC;YACnF,iBAAiB,GAAG,IAAI,CAAC,GAAG,CAAC,yBAAyB,EAAE,iBAAiB,CAAC,CAAC;QAC7E,CAAC;QAED,MAAM,UAAU,GAAG,WAAW,GAAG,iBAAiB,CAAC;QACnD,IAAI,iBAAiB,EAAE,CAAC;YACtB,IAAI,CAAC,8BAA8B,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;QAC3D,CAAC;QAED,OAAO,iBAAiB,CAAC;IAC3B,CAAC;IAED,8BAA8B,CAAC,OAA+B,EAAE,UAAkB;QAChF,MAAM,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC;QACtC,MAAM,UAAU,GAAG,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,EAAC,UAAU,EAAC,CAAC;QACzE,UAAU,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;QACpE,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACpD,CAAC;IAED;;;OAGG;IACH,aAAa,CAAC,MAAc,EAAE,UAAkB;QAC9C,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,MAAM,EAAE,EAAC,UAAU,EAAC,CAAC,CAAC;IACtD,CAAC;;AAGH,OAAO,EAAC,QAAQ,EAAC,CAAC","sourcesContent":["// Copyright 2024 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\n\nimport type * as Lantern from '../types/types.js';\n\n// A DNS lookup will usually take ~1-2 roundtrips of connection latency plus the extra DNS routing time.\n// Example: https://www.webpagetest.org/result/180703_3A_e33ec79747c002ed4d7bcbfc81462203/1/details/#waterfall_view_step1\n// Example: https://www.webpagetest.org/result/180707_1M_89673eb633b5d98386de95dfcf9b33d5/1/details/#waterfall_view_step1\n// DNS is highly variable though, many times it's a little more than 1, but can easily be 4-5x RTT.\n// We'll use 2 since it seems to give the most accurate results on average, but this can be tweaked.\nconst DNS_RESOLUTION_RTT_MULTIPLIER = 2;\n\nclass DNSCache {\n  static rttMultiplier = DNS_RESOLUTION_RTT_MULTIPLIER;\n\n  _rtt: number;\n  _resolvedDomainNames: Map<string, {resolvedAt: number}>;\n\n  constructor({rtt}: {rtt: number}) {\n    this._rtt = rtt;\n    this._resolvedDomainNames = new Map();\n  }\n\n  getTimeUntilResolution(request: Lantern.NetworkRequest, options?: {requestedAt: number, shouldUpdateCache: boolean}):\n      number {\n    const {requestedAt = 0, shouldUpdateCache = false} = options || {};\n\n    const domain = request.parsedURL.host;\n    const cacheEntry = this._resolvedDomainNames.get(domain);\n    let timeUntilResolved = this._rtt * DNSCache.rttMultiplier;\n    if (cacheEntry) {\n      const timeUntilCachedIsResolved = Math.max(cacheEntry.resolvedAt - requestedAt, 0);\n      timeUntilResolved = Math.min(timeUntilCachedIsResolved, timeUntilResolved);\n    }\n\n    const resolvedAt = requestedAt + timeUntilResolved;\n    if (shouldUpdateCache) {\n      this._updateCacheResolvedAtIfNeeded(request, resolvedAt);\n    }\n\n    return timeUntilResolved;\n  }\n\n  _updateCacheResolvedAtIfNeeded(request: Lantern.NetworkRequest, resolvedAt: number): void {\n    const domain = request.parsedURL.host;\n    const cacheEntry = this._resolvedDomainNames.get(domain) || {resolvedAt};\n    cacheEntry.resolvedAt = Math.min(cacheEntry.resolvedAt, resolvedAt);\n    this._resolvedDomainNames.set(domain, cacheEntry);\n  }\n\n  /**\n   * Forcefully sets the DNS resolution time for a request.\n   * Useful for testing and alternate execution simulations.\n   */\n  setResolvedAt(domain: string, resolvedAt: number): void {\n    this._resolvedDomainNames.set(domain, {resolvedAt});\n  }\n}\n\nexport {DNSCache};\n"]}

package/models/trace/lantern/simulation/NetworkAnalyzer.d.ts

@@ -0,0 +1,112 @@
+import type * as Lantern from '../types/lantern.js';
+interface Summary {
+    min: number;
+    max: number;
+    avg: number;
+    median: number;
+}
+interface RTTEstimateOptions {
+    /**
+     * TCP connection handshake information will be used when available, but in
+     * some circumstances this data can be unreliable. This flag exposes an
+     * option to ignore the handshake data and use the coarse download/TTFB timing data.
+     */
+    forceCoarseEstimates?: boolean;
+    /**
+     * Coarse estimates include lots of extra time and noise multiply by some factor
+     * to deflate the estimates a bit.
+     */
+    coarseEstimateMultiplier?: number;
+    /** Useful for testing to isolate the different methods of estimation. */
+    useDownloadEstimates?: boolean;
+    /** Useful for testing to isolate the different methods of estimation. */
+    useSendStartEstimates?: boolean;
+    /** Useful for testing to isolate the different methods of estimation. */
+    useHeadersEndEstimates?: boolean;
+}
+type RequestInfo = {
+    request: Lantern.NetworkRequest;
+    timing: Lantern.ResourceTiming;
+    connectionReused?: boolean;
+};
+declare class NetworkAnalyzer {
+    static get summary(): string;
+    static groupByOrigin(records: Lantern.NetworkRequest[]): Map<string, Lantern.NetworkRequest[]>;
+    static getSummary(values: number[]): Summary;
+    static summarize(values: Map<string, number[]>): Map<string, Summary>;
+    static _estimateValueByOrigin(requests: Lantern.NetworkRequest[], iteratee: (e: RequestInfo) => number | number[] | undefined): Map<string, number[]>;
+    /**
+     * Estimates the observed RTT to each origin based on how long the connection setup.
+     * For h1 and h2, this could includes two estimates - one for the TCP handshake, another for
+     * SSL negotiation.
+     * For h3, we get only one estimate since QUIC establishes a secure connection in a
+     * single handshake.
+     * This is the most accurate and preferred method of measurement when the data is available.
+     */
+    static _estimateRTTViaConnectionTiming(info: RequestInfo): number[] | number | undefined;
+    /**
+     * Estimates the observed RTT to each origin based on how long a download took on a fresh connection.
+     * NOTE: this will tend to overestimate the actual RTT quite significantly as the download can be
+     * slow for other reasons as well such as bandwidth constraints.
+     */
+    static _estimateRTTViaDownloadTiming(info: RequestInfo): number | undefined;
+    /**
+     * Estimates the observed RTT to each origin based on how long it took until Chrome could
+     * start sending the actual request when a new connection was required.
+     * NOTE: this will tend to overestimate the actual RTT as the request can be delayed for other
+     * reasons as well such as more SSL handshakes if TLS False Start is not enabled.
+     */
+    static _estimateRTTViaSendStartTiming(info: RequestInfo): number | undefined;
+    /**
+     * Estimates the observed RTT to each origin based on how long it took until Chrome received the
+     * headers of the response (~TTFB).
+     * NOTE: this is the most inaccurate way to estimate the RTT, but in some environments it's all
+     * we have access to :(
+     */
+    static _estimateRTTViaHeadersEndTiming(info: RequestInfo): number | undefined;
+    /**
+     * Given the RTT to each origin, estimates the observed server response times.
+     */
+    static _estimateResponseTimeByOrigin(records: Lantern.NetworkRequest[], rttByOrigin: Map<string, number>): Map<string, number[]>;
+    static canTrustConnectionInformation(requests: Lantern.NetworkRequest[]): boolean;
+    /**
+     * Returns a map of requestId -> connectionReused, estimating the information if the information
+     * available in the records themselves appears untrustworthy.
+     */
+    static estimateIfConnectionWasReused(records: Lantern.NetworkRequest[], options?: {
+        forceCoarseEstimates: boolean;
+    }): Map<string, boolean>;
+    /**
+     * Estimates the RTT to each origin by examining observed network timing information.
+     * Attempts to use the most accurate information first and falls back to coarser estimates when it
+     * is unavailable.
+     */
+    static estimateRTTByOrigin(records: Lantern.NetworkRequest[], options?: RTTEstimateOptions): Map<string, Summary>;
+    /**
+     * Estimates the server response time of each origin. RTT times can be passed in or will be
+     * estimated automatically if not provided.
+     */
+    static estimateServerResponseTimeByOrigin(records: Lantern.NetworkRequest[], options?: RTTEstimateOptions & {
+        rttByOrigin?: Map<string, number>;
+    }): Map<string, Summary>;
+    /**
+     * Computes the average throughput for the given requests in bits/second.
+     * Excludes data URI, failed or otherwise incomplete, and cached requests.
+     * Returns Infinity if there were no analyzable network requests.
+     */
+    static estimateThroughput(records: Lantern.NetworkRequest[]): number;
+    static computeRTTAndServerResponseTime(records: Lantern.NetworkRequest[]): {
+        rtt: number;
+        additionalRttByOrigin: Map<string, number>;
+        serverResponseTimeByOrigin: Map<string, number>;
+    };
+    static analyze(records: Lantern.NetworkRequest[]): Lantern.Simulation.Settings['networkAnalysis'];
+    static findResourceForUrl<T extends Lantern.NetworkRequest>(records: Array<T>, resourceUrl: string): T | undefined;
+    static findLastDocumentForUrl<T extends Lantern.NetworkRequest>(records: Array<T>, resourceUrl: string): T | undefined;
+    /**
+     * Resolves redirect chain given a main document.
+     * See: {@link NetworkAnalyzer.findLastDocumentForUrl} for how to retrieve main document.
+     */
+    static resolveRedirects<T extends Lantern.NetworkRequest>(request: T): T;
+}
+export { NetworkAnalyzer };