pagespeed-quest 0.3.2 → 0.3.3

package/build/recording.js

@@ -0,0 +1,94 @@
+import { Proxy } from './proxy.js';
+export class RecordingProxy extends Proxy {
+    startedAt;
+    transactions = [];
+    async setup() {
+        this.startedAt = new Date();
+        let requestNumber = 1;
+        this.proxy.onRequest((ctx, onRequestComplete) => {
+            const number = requestNumber++;
+            // Throttling
+            const filter = this.createThrottlingTransform();
+            if (filter)
+                ctx.addResponseFilter(filter);
+            const identifier = Proxy.contextRequest(ctx);
+            const transaction = {
+                startedAt: new Date(),
+                ...identifier,
+                contentChunks: [],
+            };
+            this.dependency.logger?.debug({ number, identifier }, `Request #${number} ${transaction.url} started`);
+            ctx.onError((_, err, errKind) => {
+                transaction.responseStartedAt = new Date();
+                transaction.err = err;
+                transaction.errKind = errKind;
+                this.dependency.logger?.warn({ number, identifier, err }, `Request #${number} ${transaction.url} failed: ${err.message}`);
+            });
+            ctx.onResponse((_, onResponseComplete) => {
+                transaction.responseStartedAt = new Date();
+                transaction.statusCode = ctx.serverToProxyResponse.statusCode;
+                transaction.incomingHttpHeaders = ctx.serverToProxyResponse.headers;
+                this.dependency.logger?.debug({ number, identifier }, `Request #${number} ${transaction.url} responded`);
+                onResponseComplete();
+            });
+            ctx.onResponseData((_, chunk, onResponseDataComplete) => {
+                transaction.contentChunks.push(chunk);
+                onResponseDataComplete(null, chunk);
+            });
+            ctx.onResponseEnd((_, onResponseEndComplete) => {
+                transaction.responseEndedAt = new Date();
+                this.transactions.push(transaction);
+                this.dependency.logger?.debug({ number, identifier }, `Request #${number} ${transaction.url} completed`);
+                onResponseEndComplete();
+            });
+            onRequestComplete();
+        });
+    }
+    async saveInventory() {
+        const transactions = [];
+        for (const requestTransaction of this.transactions) {
+            const transaction = {
+                method: requestTransaction.method,
+                url: requestTransaction.url,
+                ttfbMs: 0,
+                content: Buffer.concat(requestTransaction.contentChunks),
+            };
+            // ttfb and duration
+            if (requestTransaction.responseStartedAt) {
+                transaction.ttfbMs = +requestTransaction.responseStartedAt - +requestTransaction.startedAt;
+                if (requestTransaction.responseEndedAt) {
+                    transaction.durationMs = +requestTransaction.responseEndedAt - +requestTransaction.responseStartedAt;
+                }
+            }
+            // error
+            if (requestTransaction.err) {
+                transaction.errorMessage = requestTransaction.err.message;
+            }
+            // status code
+            if (requestTransaction.statusCode) {
+                transaction.statusCode = requestTransaction.statusCode;
+            }
+            // headers
+            if (requestTransaction.incomingHttpHeaders) {
+                transaction.rawHeaders = {};
+                for (const [key, value] of Object.entries(requestTransaction.incomingHttpHeaders)) {
+                    transaction.rawHeaders[key.toLowerCase()] = value.toString();
+                }
+            }
+            transactions.push(transaction);
+        }
+        const resources = await this.inventoryRepository.saveTransactions(transactions);
+        const inventory = { entryUrl: this.entryUrl, deviceType: this.deviceType, resources };
+        await this.inventoryRepository.saveInventory(inventory);
+    }
+    async shutdown() {
+        await this.saveInventory();
+    }
+}
+export async function withRecordingProxy(options, dependency, cb) {
+    const proxy = new RecordingProxy(options, dependency);
+    await proxy.start();
+    await cb(proxy);
+    await proxy.stop();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/throttling.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Transform, TransformCallback } from 'stream';
+export declare class ThrottlingLog {
+    ms: number;
+    bytes: number;
+}
+export declare class Throttle {
+    flushIntervalMs: number;
+    limitBytes: number;
+    currentBytes: number;
+    interval?: ReturnType<typeof setInterval>;
+    logs: ThrottlingLog[];
+    constructor(limitBytes: number, flushIntervalMs?: number);
+    static fromMbps(mbps: number, flushIntervalMs?: number): Throttle;
+    computeCapacity(): {
+        consumed: number;
+        carryover: number;
+    };
+    start(): void;
+    stop(): void;
+    checkAndStack(bytes: number): boolean;
+    simpleReport(unitMs?: number): {
+        maxBytesPerUnit: number;
+        avgBytesPerUnit: number;
+    };
+}
+export declare class ThrottlingTransform extends Transform {
+    throttle: Throttle;
+    retryIntervalMs: number;
+    constructor(throttle: Throttle, retryIntervalMs: number);
+    _transform(chunk: string | Buffer, _: string, done: TransformCallback): void;
+}

package/build/throttling.js

@@ -0,0 +1,89 @@
+import { Transform } from 'stream';
+export class ThrottlingLog {
+    ms;
+    bytes;
+}
+export class Throttle {
+    flushIntervalMs;
+    limitBytes;
+    currentBytes = 0;
+    interval;
+    logs = [];
+    constructor(limitBytes, flushIntervalMs) {
+        this.limitBytes = limitBytes;
+        this.flushIntervalMs = flushIntervalMs ?? 100;
+    }
+    static fromMbps(mbps, flushIntervalMs) {
+        const bytesPerSec = (mbps * 1024 * 1024) / 8;
+        const limitBytes = Math.floor((bytesPerSec * flushIntervalMs) / 1000);
+        return new Throttle(limitBytes, flushIntervalMs);
+    }
+    computeCapacity() {
+        const consumed = Math.min(this.currentBytes, this.limitBytes);
+        const carryover = this.currentBytes - consumed;
+        return { consumed, carryover };
+    }
+    start() {
+        this.interval = setInterval(() => {
+            const c = this.computeCapacity();
+            this.logs.push({
+                ms: Date.now(),
+                bytes: c.consumed,
+            });
+            this.currentBytes = c.carryover;
+        }, this.flushIntervalMs);
+    }
+    stop() {
+        if (this.interval)
+            clearInterval(this.interval);
+    }
+    checkAndStack(bytes) {
+        if (!this.interval)
+            throw new Error('Throttle is not started');
+        if (this.currentBytes >= this.limitBytes) {
+            return false;
+        }
+        this.currentBytes += bytes;
+        return true;
+    }
+    simpleReport(unitMs = 1000) {
+        const bySec = new Map();
+        for (const log of this.logs) {
+            const unit = Math.floor(log.ms / unitMs);
+            if (!bySec.has(unit))
+                bySec.set(unit, 0);
+            bySec.set(unit, bySec.get(unit) + log.bytes);
+        }
+        const values = Array.from(bySec.values());
+        const maxBytesPerUnit = Math.max(...values);
+        const avgBytesPerUnit = Math.floor(values.reduce((a, b) => a + b, 0) / bySec.size) / 1024 / 1024;
+        return {
+            maxBytesPerUnit,
+            avgBytesPerUnit,
+        };
+    }
+}
+export class ThrottlingTransform extends Transform {
+    throttle;
+    retryIntervalMs;
+    constructor(throttle, retryIntervalMs) {
+        super();
+        this.throttle = throttle;
+        this.retryIntervalMs = retryIntervalMs;
+    }
+    _transform(chunk, _, done) {
+        if (this.throttle.checkAndStack(chunk.length)) {
+            this.push(chunk);
+            done();
+            return;
+        }
+        const interval = setInterval(() => {
+            if (this.throttle.checkAndStack(chunk.length)) {
+                clearInterval(interval);
+                this.push(chunk);
+                done();
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/types.d.ts

@@ -0,0 +1,8 @@
+import Pino from 'pino';
+export type DeviceType = 'desktop' | 'mobile';
+export interface DependencyInterface {
+    logger?: Pino.Logger;
+    mkdirp(dirPath: string): Promise<void>;
+    executeLighthouse(args: string[]): Promise<void>;
+    executeLoadshow(args: string[]): Promise<void>;
+}

package/build/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pagespeed-quest",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "type": "module",
   "description": "A framework for efficient web front-end speed improvement",
   "main": "build/index.js",
@@ -45,7 +45,8 @@
     "reset-hard": "git clean -dfx && git reset --hard && yarn",
     "prepare-release": "run-s reset-hard test cov:check doc:html version doc:publish",
     "adhoc": "yarn build && node build/adhoc.js",
-    "command": "yarn build && node build/command.js"
+    "command": "yarn build && node build/command.js",
+    "prepublishOnly": "yarn build"
   },
   "engines": {
     "node": ">=18"