firebase-tools 10.9.2 → 11.1.0

package/lib/profileReport.js

@@ -1,41 +1,24 @@
 "use strict";
-var clc = require("cli-color");
-var Table = require("cli-table");
-var fs = require("fs");
-var _ = require("lodash");
-var readline = require("readline");
-var { FirebaseError } = require("./error");
-const { logger } = require("./logger");
-var DATA_LINE_REGEX = /^data: /;
-var BANDWIDTH_NOTE = "NOTE: The numbers reported here are only estimates of the data" +
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfileReport = exports.extractReadableIndex = exports.formatBytes = exports.formatNumber = exports.pathString = exports.extractJSON = void 0;
+const clc = require("cli-color");
+const Table = require("cli-table");
+const fs = require("fs");
+const _ = require("lodash");
+const readline = require("readline");
+const error_1 = require("./error");
+const logger_1 = require("./logger");
+const DATA_LINE_REGEX = /^data: /;
+const BANDWIDTH_NOTE = "NOTE: The numbers reported here are only estimates of the data" +
     " payloads from read operations. They are NOT a valid measure of your bandwidth bill.";
-var SPEED_NOTE = "NOTE: Speeds are reported at millisecond resolution and" +
+const SPEED_NOTE = "NOTE: Speeds are reported at millisecond resolution and" +
     " are not the latencies that clients will see. Pending times" +
     " are also reported at millisecond resolution. They approximate" +
     " the interval of time between the instant a request is received" +
     " and the instant it executes.";
-var COLLAPSE_THRESHOLD = 25;
-var COLLAPSE_WILDCARD = ["$wildcard"];
-var ProfileReport = function (tmpFile, outStream, options) {
-    this.tempFile = tmpFile;
-    this.output = outStream;
-    this.options = options;
-    this.state = {
-        outband: {},
-        inband: {},
-        writeSpeed: {},
-        broadcastSpeed: {},
-        readSpeed: {},
-        connectSpeed: {},
-        disconnectSpeed: {},
-        unlistenSpeed: {},
-        unindexed: {},
-        startTime: 0,
-        endTime: 0,
-        opCount: 0,
-    };
-};
-ProfileReport.extractJSON = function (line, input) {
+const COLLAPSE_THRESHOLD = 25;
+const COLLAPSE_WILDCARD = ["$wildcard"];
+function extractJSON(line, input) {
     if (!input && !DATA_LINE_REGEX.test(line)) {
         return null;
     }
@@ -48,536 +31,545 @@ ProfileReport.extractJSON = function (line, input) {
     catch (e) {
         return null;
     }
-};
-ProfileReport.pathString = function (path) {
-    return "/" + (path ? path.join("/") : "");
-};
-ProfileReport.formatNumber = function (num) {
-    var parts = num.toFixed(2).split(".");
+}
+exports.extractJSON = extractJSON;
+function pathString(path) {
+    return `/${path ? path.join("/") : ""}`;
+}
+exports.pathString = pathString;
+function formatNumber(num) {
+    const parts = num.toFixed(2).split(".");
     parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ",");
     if (+parts[1] === 0) {
         return parts[0];
     }
     return parts.join(".");
-};
-ProfileReport.formatBytes = function (bytes) {
-    var threshold = 1000;
+}
+exports.formatNumber = formatNumber;
+function formatBytes(bytes) {
+    const threshold = 1000;
     if (Math.round(bytes) < threshold) {
         return bytes + " B";
     }
-    var units = ["kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
-    var u = -1;
-    var formattedBytes = bytes;
+    const units = ["kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+    let u = -1;
+    let formattedBytes = bytes;
     do {
         formattedBytes /= threshold;
         u++;
     } while (Math.abs(formattedBytes) >= threshold && u < units.length - 1);
-    return ProfileReport.formatNumber(formattedBytes) + " " + units[u];
-};
-ProfileReport.extractReadableIndex = function (query) {
+    return formatNumber(formattedBytes) + " " + units[u];
+}
+exports.formatBytes = formatBytes;
+function extractReadableIndex(query) {
     if (_.has(query, "orderBy")) {
         return query.orderBy;
     }
-    var indexPath = _.get(query, "index.path");
+    const indexPath = _.get(query, "index.path");
     if (indexPath) {
-        return ProfileReport.pathString(indexPath);
+        return pathString(indexPath);
     }
     return ".value";
-};
-ProfileReport.prototype.collectUnindexed = function (data, path) {
-    if (!data.unIndexed) {
-        return;
-    }
-    if (!_.has(this.state.unindexed, path)) {
-        this.state.unindexed[path] = {};
-    }
-    var pathNode = this.state.unindexed[path];
-    var query = data.querySet[0];
-    var index = JSON.stringify(query.index);
-    if (!_.has(pathNode, index)) {
-        pathNode[index] = {
-            times: 0,
-            query: query,
+}
+exports.extractReadableIndex = extractReadableIndex;
+class ProfileReport {
+    constructor(tmpFile, outStream, options = {}) {
+        this.tempFile = tmpFile;
+        this.output = outStream;
+        this.options = options;
+        this.state = {
+            outband: {},
+            inband: {},
+            writeSpeed: {},
+            broadcastSpeed: {},
+            readSpeed: {},
+            connectSpeed: {},
+            disconnectSpeed: {},
+            unlistenSpeed: {},
+            unindexed: {},
+            startTime: 0,
+            endTime: 0,
+            opCount: 0,
         };
     }
-    var indexNode = pathNode[index];
-    indexNode.times += 1;
-};
-ProfileReport.prototype.collectSpeedUnpathed = function (data, opStats) {
-    if (Object.keys(opStats).length === 0) {
-        opStats.times = 0;
-        opStats.millis = 0;
-        opStats.pendingCount = 0;
-        opStats.pendingTime = 0;
-        opStats.rejected = 0;
-    }
-    opStats.times += 1;
-    if (data.hasOwnProperty("millis")) {
-        opStats.millis += data.millis;
-    }
-    if (data.hasOwnProperty("pendingTime")) {
-        opStats.pendingCount++;
-        opStats.pendingTime += data.pendingTime;
-    }
-    if (data.allowed === false) {
-        opStats.rejected += 1;
-    }
-};
-ProfileReport.prototype.collectSpeed = function (data, path, opType) {
-    if (!_.has(opType, path)) {
-        opType[path] = {
-            times: 0,
-            millis: 0,
-            pendingCount: 0,
-            pendingTime: 0,
-            rejected: 0,
-        };
+    collectUnindexed(data, path) {
+        if (!data.unIndexed) {
+            return;
+        }
+        if (!_.has(this.state.unindexed, path)) {
+            this.state.unindexed[path] = {};
+        }
+        const pathNode = this.state.unindexed[path];
+        const query = data.querySet[0];
+        const index = JSON.stringify(query.index);
+        if (!_.has(pathNode, index)) {
+            pathNode[index] = {
+                times: 0,
+                query: query,
+            };
+        }
+        const indexNode = pathNode[index];
+        indexNode.times += 1;
+    }
+    collectSpeedUnpathed(data, opStats) {
+        if (Object.keys(opStats).length === 0) {
+            opStats.times = 0;
+            opStats.millis = 0;
+            opStats.pendingCount = 0;
+            opStats.pendingTime = 0;
+            opStats.rejected = 0;
+        }
+        opStats.times += 1;
+        if (data.hasOwnProperty("millis")) {
+            opStats.millis += data.millis;
+        }
+        if (data.hasOwnProperty("pendingTime")) {
+            opStats.pendingCount++;
+            opStats.pendingTime += data.pendingTime;
+        }
+        if (data.allowed === false) {
+            opStats.rejected += 1;
+        }
+    }
+    collectSpeed(data, path, opType) {
+        if (!_.has(opType, path)) {
+            opType[path] = {
+                times: 0,
+                millis: 0,
+                pendingCount: 0,
+                pendingTime: 0,
+                rejected: 0,
+            };
+        }
+        const node = opType[path];
+        node.times += 1;
+        if (data.hasOwnProperty("millis")) {
+            node.millis += data.millis;
+        }
+        if (data.hasOwnProperty("pendingTime")) {
+            node.pendingCount++;
+            node.pendingTime += data.pendingTime;
+        }
+        if (data.allowed === false) {
+            node.rejected += 1;
+        }
     }
-    var node = opType[path];
-    node.times += 1;
-    if (data.hasOwnProperty("millis")) {
-        node.millis += data.millis;
+    collectBandwidth(bytes, path, direction) {
+        if (!_.has(direction, path)) {
+            direction[path] = {
+                times: 0,
+                bytes: 0,
+            };
+        }
+        const node = direction[path];
+        node.times += 1;
+        node.bytes += bytes;
     }
-    if (data.hasOwnProperty("pendingTime")) {
-        node.pendingCount++;
-        node.pendingTime += data.pendingTime;
+    collectRead(data, path, bytes) {
+        this.collectSpeed(data, path, this.state.readSpeed);
+        this.collectBandwidth(bytes, path, this.state.outband);
     }
-    if (data.allowed === false) {
-        node.rejected += 1;
+    collectBroadcast(data, path, bytes) {
+        this.collectSpeed(data, path, this.state.broadcastSpeed);
+        this.collectBandwidth(bytes, path, this.state.outband);
     }
-};
-ProfileReport.prototype.collectBandwidth = function (bytes, path, direction) {
-    if (!_.has(direction, path)) {
-        direction[path] = {
-            times: 0,
-            bytes: 0,
-        };
+    collectUnlisten(data, path) {
+        this.collectSpeed(data, path, this.state.unlistenSpeed);
+    }
+    collectConnect(data) {
+        this.collectSpeedUnpathed(data, this.state.connectSpeed);
+    }
+    collectDisconnect(data) {
+        this.collectSpeedUnpathed(data, this.state.disconnectSpeed);
+    }
+    collectWrite(data, path, bytes) {
+        this.collectSpeed(data, path, this.state.writeSpeed);
+        this.collectBandwidth(bytes, path, this.state.inband);
+    }
+    processOperation(data) {
+        if (!this.state.startTime) {
+            this.state.startTime = data.timestamp;
+        }
+        this.state.endTime = data.timestamp;
+        const path = pathString(data.path);
+        this.state.opCount++;
+        switch (data.name) {
+            case "concurrent-connect":
+                this.collectConnect(data);
+                break;
+            case "concurrent-disconnect":
+                this.collectDisconnect(data);
+                break;
+            case "realtime-read":
+                this.collectRead(data, path, data.bytes);
+                break;
+            case "realtime-write":
+                this.collectWrite(data, path, data.bytes);
+                break;
+            case "realtime-transaction":
+                this.collectWrite(data, path, data.bytes);
+                break;
+            case "realtime-update":
+                this.collectWrite(data, path, data.bytes);
+                break;
+            case "listener-listen":
+                this.collectRead(data, path, data.bytes);
+                this.collectUnindexed(data, path);
+                break;
+            case "listener-broadcast":
+                this.collectBroadcast(data, path, data.bytes);
+                break;
+            case "listener-unlisten":
+                this.collectUnlisten(data, path);
+                break;
+            case "rest-read":
+                this.collectRead(data, path, data.bytes);
+                break;
+            case "rest-write":
+                this.collectWrite(data, path, data.bytes);
+                break;
+            case "rest-update":
+                this.collectWrite(data, path, data.bytes);
+                break;
+            default:
+                break;
+        }
     }
-    var node = direction[path];
-    node.times += 1;
-    node.bytes += bytes;
-};
-ProfileReport.prototype.collectRead = function (data, path, bytes) {
-    this.collectSpeed(data, path, this.state.readSpeed);
-    this.collectBandwidth(bytes, path, this.state.outband);
-};
-ProfileReport.prototype.collectBroadcast = function (data, path, bytes) {
-    this.collectSpeed(data, path, this.state.broadcastSpeed);
-    this.collectBandwidth(bytes, path, this.state.outband);
-};
-ProfileReport.prototype.collectUnlisten = function (data, path) {
-    this.collectSpeed(data, path, this.state.unlistenSpeed);
-};
-ProfileReport.prototype.collectConnect = function (data) {
-    this.collectSpeedUnpathed(data, this.state.connectSpeed);
-};
-ProfileReport.prototype.collectDisconnect = function (data) {
-    this.collectSpeedUnpathed(data, this.state.disconnectSpeed);
-};
-ProfileReport.prototype.collectWrite = function (data, path, bytes) {
-    this.collectSpeed(data, path, this.state.writeSpeed);
-    this.collectBandwidth(bytes, path, this.state.inband);
-};
-ProfileReport.prototype.processOperation = function (data) {
-    if (!this.state.startTime) {
-        this.state.startTime = data.timestamp;
-    }
-    this.state.endTime = data.timestamp;
-    var path = ProfileReport.pathString(data.path);
-    this.state.opCount++;
-    switch (data.name) {
-        case "concurrent-connect":
-            this.collectConnect(data);
-            break;
-        case "concurrent-disconnect":
-            this.collectDisconnect(data);
-            break;
-        case "realtime-read":
-            this.collectRead(data, path, data.bytes);
-            break;
-        case "realtime-write":
-            this.collectWrite(data, path, data.bytes);
-            break;
-        case "realtime-transaction":
-            this.collectWrite(data, path, data.bytes);
-            break;
-        case "realtime-update":
-            this.collectWrite(data, path, data.bytes);
-            break;
-        case "listener-listen":
-            this.collectRead(data, path, data.bytes);
-            this.collectUnindexed(data, path);
-            break;
-        case "listener-broadcast":
-            this.collectBroadcast(data, path, data.bytes);
-            break;
-        case "listener-unlisten":
-            this.collectUnlisten(data, path);
-            break;
-        case "rest-read":
-            this.collectRead(data, path, data.bytes);
-            break;
-        case "rest-write":
-            this.collectWrite(data, path, data.bytes);
-            break;
-        case "rest-update":
-            this.collectWrite(data, path, data.bytes);
-            break;
-        default:
-            break;
-    }
-};
-ProfileReport.prototype.collapsePaths = function (pathedObject, combiner, pathIndex) {
-    if (!this.options.collapse) {
-        return pathedObject;
-    }
-    if (_.isUndefined(pathIndex)) {
-        pathIndex = 1;
-    }
-    var allSegments = _.keys(pathedObject).map(function (path) {
-        return path.split("/").filter(function (s) {
-            return s !== "";
+    collapsePaths(pathedObject, combiner, pathIndex = 1) {
+        if (!this.options.collapse) {
+            return pathedObject;
+        }
+        const allSegments = _.keys(pathedObject).map((path) => {
+            return path.split("/").filter((s) => {
+                return s !== "";
+            });
         });
-    });
-    var pathSegments = allSegments.filter(function (segments) {
-        return segments.length > pathIndex;
-    });
-    var otherSegments = allSegments.filter(function (segments) {
-        return segments.length <= pathIndex;
-    });
-    if (pathSegments.length === 0) {
-        return pathedObject;
-    }
-    var prefixes = {};
-    pathSegments.forEach(function (segments) {
-        var prefixPath = ProfileReport.pathString(segments.slice(0, pathIndex));
-        var prefixCount = _.get(prefixes, prefixPath, new Set());
-        prefixes[prefixPath] = prefixCount.add(segments[pathIndex]);
-    });
-    var collapsedObject = {};
-    pathSegments.forEach(function (segments) {
-        var prefix = segments.slice(0, pathIndex);
-        var prefixPath = ProfileReport.pathString(prefix);
-        var prefixCount = _.get(prefixes, prefixPath);
-        var originalPath = ProfileReport.pathString(segments);
-        if (prefixCount.size >= COLLAPSE_THRESHOLD) {
-            var tail = segments.slice(pathIndex + 1);
-            var collapsedPath = ProfileReport.pathString(prefix.concat(COLLAPSE_WILDCARD).concat(tail));
-            var currentValue = collapsedObject[collapsedPath];
-            if (currentValue) {
-                collapsedObject[collapsedPath] = combiner(currentValue, pathedObject[originalPath]);
+        const pathSegments = allSegments.filter((segments) => {
+            return segments.length > pathIndex;
+        });
+        const otherSegments = allSegments.filter((segments) => {
+            return segments.length <= pathIndex;
+        });
+        if (pathSegments.length === 0) {
+            return pathedObject;
+        }
+        const prefixes = {};
+        pathSegments.forEach((segments) => {
+            const prefixPath = pathString(segments.slice(0, pathIndex));
+            const prefixCount = _.get(prefixes, prefixPath, new Set());
+            prefixes[prefixPath] = prefixCount.add(segments[pathIndex]);
+        });
+        const collapsedObject = {};
+        pathSegments.forEach((segments) => {
+            const prefix = segments.slice(0, pathIndex);
+            const prefixPath = pathString(prefix);
+            const prefixCount = _.get(prefixes, prefixPath);
+            const originalPath = pathString(segments);
+            if (prefixCount.size >= COLLAPSE_THRESHOLD) {
+                const tail = segments.slice(pathIndex + 1);
+                const collapsedPath = pathString(prefix.concat(COLLAPSE_WILDCARD).concat(tail));
+                const currentValue = collapsedObject[collapsedPath];
+                if (currentValue) {
+                    collapsedObject[collapsedPath] = combiner(currentValue, pathedObject[originalPath]);
+                }
+                else {
+                    collapsedObject[collapsedPath] = pathedObject[originalPath];
+                }
             }
             else {
-                collapsedObject[collapsedPath] = pathedObject[originalPath];
+                collapsedObject[originalPath] = pathedObject[originalPath];
             }
-        }
-        else {
+        });
+        otherSegments.forEach((segments) => {
+            const originalPath = pathString(segments);
             collapsedObject[originalPath] = pathedObject[originalPath];
-        }
-    });
-    otherSegments.forEach(function (segments) {
-        var originalPath = ProfileReport.pathString(segments);
-        collapsedObject[originalPath] = pathedObject[originalPath];
-    });
-    return this.collapsePaths(collapsedObject, combiner, pathIndex + 1);
-};
-ProfileReport.prototype.renderUnindexedData = function () {
-    var table = new Table({
-        head: ["Path", "Index", "Count"],
-        style: {
-            head: this.options.isFile ? [] : ["yellow"],
-            border: this.options.isFile ? [] : ["grey"],
-        },
-    });
-    var unindexed = this.collapsePaths(this.state.unindexed, function (u1, u2) {
-        _.mergeWith(u1, u2, function (p1, p2) {
+        });
+        return this.collapsePaths(collapsedObject, combiner, pathIndex + 1);
+    }
+    renderUnindexedData() {
+        const table = new Table({
+            head: ["Path", "Index", "Count"],
+            style: {
+                head: this.options.isFile ? [] : ["yellow"],
+                border: this.options.isFile ? [] : ["grey"],
+            },
+        });
+        const unindexed = this.collapsePaths(this.state.unindexed, (u1, u2) => {
+            _.mergeWith(u1, u2, (p1, p2) => {
+                return {
+                    times: p1.times + p2.times,
+                    query: p1.query,
+                };
+            });
+        });
+        const paths = _.keys(unindexed);
+        paths.forEach((path) => {
+            const indices = _.keys(unindexed[path]);
+            indices.forEach((index) => {
+                const data = unindexed[path][index];
+                const row = [path, extractReadableIndex(data.query), formatNumber(data.times)];
+                table.push(row);
+            });
+        });
+        return table;
+    }
+    renderBandwidth(pureData) {
+        const table = new Table({
+            head: ["Path", "Total", "Count", "Average"],
+            style: {
+                head: this.options.isFile ? [] : ["yellow"],
+                border: this.options.isFile ? [] : ["grey"],
+            },
+        });
+        const data = this.collapsePaths(pureData, (b1, b2) => {
             return {
-                times: p1.times + p2.times,
-                query: p1.query,
+                bytes: b1.bytes + b2.bytes,
+                times: b1.times + b2.times,
             };
         });
-    });
-    var paths = _.keys(unindexed);
-    paths.forEach(function (path) {
-        var indices = _.keys(unindexed[path]);
-        indices.forEach(function (index) {
-            var data = unindexed[path][index];
-            var row = [
+        const paths = _.orderBy(_.keys(data), [(p) => data[p].bytes], ["desc"]);
+        paths.forEach((path) => {
+            const bandwidth = data[path];
+            const row = [
                 path,
-                ProfileReport.extractReadableIndex(data.query),
-                ProfileReport.formatNumber(data.times),
+                formatBytes(bandwidth.bytes),
+                formatNumber(bandwidth.times),
+                formatBytes(bandwidth.bytes / bandwidth.times),
             ];
             table.push(row);
         });
-    });
-    return table;
-};
-ProfileReport.prototype.renderBandwidth = function (pureData) {
-    var table = new Table({
-        head: ["Path", "Total", "Count", "Average"],
-        style: {
-            head: this.options.isFile ? [] : ["yellow"],
-            border: this.options.isFile ? [] : ["grey"],
-        },
-    });
-    var data = this.collapsePaths(pureData, function (b1, b2) {
-        return {
-            bytes: b1.bytes + b2.bytes,
-            times: b1.times + b2.times,
-        };
-    });
-    var paths = _.keys(data);
-    paths = _.orderBy(paths, function (path) {
-        var bandwidth = data[path];
-        return bandwidth.bytes;
-    }, ["desc"]);
-    paths.forEach(function (path) {
-        var bandwidth = data[path];
-        var row = [
-            path,
-            ProfileReport.formatBytes(bandwidth.bytes),
-            ProfileReport.formatNumber(bandwidth.times),
-            ProfileReport.formatBytes(bandwidth.bytes / bandwidth.times),
-        ];
-        table.push(row);
-    });
-    return table;
-};
-ProfileReport.prototype.renderOutgoingBandwidth = function () {
-    return this.renderBandwidth(this.state.outband);
-};
-ProfileReport.prototype.renderIncomingBandwidth = function () {
-    return this.renderBandwidth(this.state.inband);
-};
-ProfileReport.prototype.renderUnpathedOperationSpeed = function (speedData, hasSecurity) {
-    var head = ["Count", "Average Execution Speed", "Average Pending Time"];
-    if (hasSecurity) {
-        head.push("Permission Denied");
-    }
-    var table = new Table({
-        head: head,
-        style: {
-            head: this.options.isFile ? [] : ["yellow"],
-            border: this.options.isFile ? [] : ["grey"],
-        },
-    });
-    if (Object.keys(speedData).length > 0) {
-        var row = [
-            speedData.times,
-            ProfileReport.formatNumber(speedData.millis / speedData.times) + " ms",
-            ProfileReport.formatNumber(speedData.pendingCount === 0 ? 0 : speedData.pendingTime / speedData.pendingCount) + " ms",
-        ];
+        return table;
+    }
+    renderOutgoingBandwidth() {
+        return this.renderBandwidth(this.state.outband);
+    }
+    renderIncomingBandwidth() {
+        return this.renderBandwidth(this.state.inband);
+    }
+    renderUnpathedOperationSpeed(speedData, hasSecurity = false) {
+        const head = ["Count", "Average Execution Speed", "Average Pending Time"];
         if (hasSecurity) {
-            row.push(ProfileReport.formatNumber(speedData.rejected));
+            head.push("Permission Denied");
         }
-        table.push(row);
-    }
-    return table;
-};
-ProfileReport.prototype.renderOperationSpeed = function (pureData, hasSecurity) {
-    var head = ["Path", "Count", "Average Execution Speed", "Average Pending Time"];
-    if (hasSecurity) {
-        head.push("Permission Denied");
-    }
-    var table = new Table({
-        head: head,
-        style: {
-            head: this.options.isFile ? [] : ["yellow"],
-            border: this.options.isFile ? [] : ["grey"],
-        },
-    });
-    var data = this.collapsePaths(pureData, function (s1, s2) {
-        return {
-            times: s1.times + s2.times,
-            millis: s1.millis + s2.millis,
-            pendingCount: s1.pendingCount + s2.pendingCount,
-            pendingTime: s1.pendingTime + s2.pendingTime,
-            rejected: s1.rejected + s2.rejected,
-        };
-    });
-    var paths = _.keys(data);
-    paths = _.orderBy(paths, function (path) {
-        var speed = data[path];
-        return speed.millis / speed.times;
-    }, ["desc"]);
-    paths.forEach(function (path) {
-        var speed = data[path];
-        var row = [
-            path,
-            speed.times,
-            ProfileReport.formatNumber(speed.millis / speed.times) + " ms",
-            ProfileReport.formatNumber(speed.pendingCount === 0 ? 0 : speed.pendingTime / speed.pendingCount) + " ms",
-        ];
+        const table = new Table({
+            head: head,
+            style: {
+                head: this.options.isFile ? [] : ["yellow"],
+                border: this.options.isFile ? [] : ["grey"],
+            },
+        });
+        if (Object.keys(speedData).length > 0) {
+            const row = [
+                speedData.times,
+                formatNumber(speedData.millis / speedData.times) + " ms",
+                formatNumber(speedData.pendingCount === 0 ? 0 : speedData.pendingTime / speedData.pendingCount) + " ms",
+            ];
+            if (hasSecurity) {
+                row.push(formatNumber(speedData.rejected));
+            }
+            table.push(row);
+        }
+        return table;
+    }
+    renderOperationSpeed(pureData, hasSecurity = false) {
+        const head = ["Path", "Count", "Average Execution Speed", "Average Pending Time"];
         if (hasSecurity) {
-            row.push(ProfileReport.formatNumber(speed.rejected));
+            head.push("Permission Denied");
         }
-        table.push(row);
-    });
-    return table;
-};
-ProfileReport.prototype.renderReadSpeed = function () {
-    return this.renderOperationSpeed(this.state.readSpeed, true);
-};
-ProfileReport.prototype.renderWriteSpeed = function () {
-    return this.renderOperationSpeed(this.state.writeSpeed, true);
-};
-ProfileReport.prototype.renderBroadcastSpeed = function () {
-    return this.renderOperationSpeed(this.state.broadcastSpeed, false);
-};
-ProfileReport.prototype.renderConnectSpeed = function () {
-    return this.renderUnpathedOperationSpeed(this.state.connectSpeed, false);
-};
-ProfileReport.prototype.renderDisconnectSpeed = function () {
-    return this.renderUnpathedOperationSpeed(this.state.disconnectSpeed, false);
-};
-ProfileReport.prototype.renderUnlistenSpeed = function () {
-    return this.renderOperationSpeed(this.state.unlistenSpeed, false);
-};
-ProfileReport.prototype.parse = function (onLine, onClose) {
-    var isFile = this.options.isFile;
-    var tmpFile = this.tempFile;
-    var outStream = this.output;
-    var isInput = this.options.isInput;
-    return new Promise(function (resolve, reject) {
-        var rl = readline.createInterface({
-            input: fs.createReadStream(tmpFile),
+        const table = new Table({
+            head: head,
+            style: {
+                head: this.options.isFile ? [] : ["yellow"],
+                border: this.options.isFile ? [] : ["grey"],
+            },
         });
-        var errored = false;
-        rl.on("line", function (line) {
-            var data = ProfileReport.extractJSON(line, isInput);
-            if (!data) {
-                return;
-            }
-            onLine(data);
+        const data = this.collapsePaths(pureData, (s1, s2) => {
+            return {
+                times: s1.times + s2.times,
+                millis: s1.millis + s2.millis,
+                pendingCount: s1.pendingCount + s2.pendingCount,
+                pendingTime: s1.pendingTime + s2.pendingTime,
+                rejected: s1.rejected + s2.rejected,
+            };
         });
-        rl.on("close", function () {
-            if (errored) {
-                reject(new FirebaseError("There was an error creating the report."));
+        let paths = _.keys(data);
+        paths = _.orderBy(paths, (path) => {
+            const speed = data[path];
+            return speed.millis / speed.times;
+        }, ["desc"]);
+        paths.forEach((path) => {
+            const speed = data[path];
+            const row = [
+                path,
+                speed.times,
+                formatNumber(speed.millis / speed.times) + " ms",
+                formatNumber(speed.pendingCount === 0 ? 0 : speed.pendingTime / speed.pendingCount) + " ms",
+            ];
+            if (hasSecurity) {
+                row.push(formatNumber(speed.rejected));
             }
-            else {
-                var result = onClose();
-                if (isFile) {
-                    outStream.on("finish", function () {
-                        resolve(result);
-                    });
-                    outStream.end();
+            table.push(row);
+        });
+        return table;
+    }
+    renderReadSpeed() {
+        return this.renderOperationSpeed(this.state.readSpeed, true);
+    }
+    renderWriteSpeed() {
+        return this.renderOperationSpeed(this.state.writeSpeed, true);
+    }
+    renderBroadcastSpeed() {
+        return this.renderOperationSpeed(this.state.broadcastSpeed, false);
+    }
+    renderConnectSpeed() {
+        return this.renderUnpathedOperationSpeed(this.state.connectSpeed, false);
+    }
+    renderDisconnectSpeed() {
+        return this.renderUnpathedOperationSpeed(this.state.disconnectSpeed, false);
+    }
+    renderUnlistenSpeed() {
+        return this.renderOperationSpeed(this.state.unlistenSpeed, false);
+    }
+    async parse(onLine, onClose) {
+        const isFile = this.options.isFile;
+        const tmpFile = this.tempFile;
+        const outStream = this.output;
+        const isInput = this.options.isInput;
+        return new Promise((resolve, reject) => {
+            const rl = readline.createInterface({
+                input: fs.createReadStream(tmpFile),
+            });
+            let errored = false;
+            rl.on("line", (line) => {
+                const data = extractJSON(line, isInput);
+                if (!data) {
+                    return;
+                }
+                onLine(data);
+            });
+            rl.on("close", () => {
+                if (errored) {
+                    reject(new error_1.FirebaseError("There was an error creating the report."));
                 }
                 else {
-                    resolve(result);
+                    const result = onClose();
+                    if (isFile) {
+                        outStream.on("finish", () => {
+                            resolve(result);
+                        });
+                        outStream.end();
+                    }
+                    else {
+                        resolve(result);
+                    }
                 }
-            }
-        });
-        rl.on("error", function () {
-            reject();
-        });
-        outStream.on("error", function () {
-            errored = true;
-            rl.close();
+            });
+            rl.on("error", () => {
+                reject();
+            });
+            outStream.on("error", () => {
+                errored = true;
+                rl.close();
+            });
         });
-    });
-};
-ProfileReport.prototype.write = function (data) {
-    if (this.options.isFile) {
-        this.output.write(data);
-    }
-    else {
-        logger.info(data);
-    }
-};
-ProfileReport.prototype.generate = function () {
-    if (this.options.format === "TXT") {
-        return this.generateText();
-    }
-    else if (this.options.format === "RAW") {
-        return this.generateRaw();
-    }
-    else if (this.options.format === "JSON") {
-        return this.generateJson();
-    }
-    throw new FirebaseError('Invalid report format expected "TXT", "JSON", or "RAW"', {
-        exit: 1,
-    });
-};
-ProfileReport.prototype.generateRaw = function () {
-    return this.parse(this.writeRaw.bind(this), function () {
-        return null;
-    });
-};
-ProfileReport.prototype.writeRaw = function (data) {
-    this.write(JSON.stringify(data) + "\n");
-};
-ProfileReport.prototype.generateText = function () {
-    return this.parse(this.processOperation.bind(this), this.outputText.bind(this));
-};
-ProfileReport.prototype.outputText = function () {
-    var totalTime = this.state.endTime - this.state.startTime;
-    var isFile = this.options.isFile;
-    var write = this.write.bind(this);
-    var writeTitle = function (title) {
-        if (isFile) {
-            write(title + "\n");
+    }
+    write(data) {
+        if (this.options.isFile) {
+            this.output.write(data);
         }
         else {
-            write(clc.bold.yellow(title) + "\n");
+            logger_1.logger.info(data);
         }
-    };
-    var writeTable = function (title, table) {
-        writeTitle(title);
-        write(table.toString() + "\n");
-    };
-    writeTitle("Report operations collected from " +
-        new Date(this.state.startTime).toISOString() +
-        " over " +
-        totalTime +
-        " ms.");
-    writeTitle("Speed Report\n");
-    write(SPEED_NOTE + "\n\n");
-    writeTable("Read Speed", this.renderReadSpeed());
-    writeTable("Write Speed", this.renderWriteSpeed());
-    writeTable("Broadcast Speed", this.renderBroadcastSpeed());
-    writeTable("Connect Speed", this.renderConnectSpeed());
-    writeTable("Disconnect Speed", this.renderDisconnectSpeed());
-    writeTable("Unlisten Speed", this.renderUnlistenSpeed());
-    writeTitle("Bandwidth Report\n");
-    write(BANDWIDTH_NOTE + "\n\n");
-    writeTable("Downloaded Bytes", this.renderOutgoingBandwidth());
-    writeTable("Uploaded Bytes", this.renderIncomingBandwidth());
-    writeTable("Unindexed Queries", this.renderUnindexedData());
-};
-ProfileReport.prototype.generateJson = function () {
-    return this.parse(this.processOperation.bind(this), this.outputJson.bind(this));
-};
-ProfileReport.prototype.outputJson = function () {
-    var totalTime = this.state.endTime - this.state.startTime;
-    var tableToJson = function (table, note) {
-        var json = {
-            legend: table.options.head,
-            data: [],
-        };
-        if (note) {
-            json.note = note;
+    }
+    generate() {
+        if (this.options.format === "TXT") {
+            return this.generateText();
+        }
+        else if (this.options.format === "RAW") {
+            return this.generateRaw();
+        }
+        else if (this.options.format === "JSON") {
+            return this.generateJson();
         }
-        table.forEach(function (row) {
-            json.data.push(row);
+        throw new error_1.FirebaseError('Invalid report format expected "TXT", "JSON", or "RAW"');
+    }
+    generateRaw() {
+        return this.parse(this.writeRaw.bind(this), () => {
+            return null;
         });
+    }
+    writeRaw(data) {
+        this.write(JSON.stringify(data) + "\n");
+    }
+    generateText() {
+        return this.parse(this.processOperation.bind(this), this.outputText.bind(this));
+    }
+    outputText() {
+        const totalTime = this.state.endTime - this.state.startTime;
+        const isFile = this.options.isFile;
+        const write = this.write.bind(this);
+        const writeTitle = (title) => {
+            if (isFile) {
+                write(title + "\n");
+            }
+            else {
+                write(clc.bold.yellow(title) + "\n");
+            }
+        };
+        const writeTable = (title, table) => {
+            writeTitle(title);
+            write(table.toString() + "\n");
+        };
+        writeTitle(`Report operations collected from ${new Date(this.state.startTime).toISOString()} over ${totalTime} ms.`);
+        writeTitle("Speed Report\n");
+        write(SPEED_NOTE + "\n\n");
+        writeTable("Read Speed", this.renderReadSpeed());
+        writeTable("Write Speed", this.renderWriteSpeed());
+        writeTable("Broadcast Speed", this.renderBroadcastSpeed());
+        writeTable("Connect Speed", this.renderConnectSpeed());
+        writeTable("Disconnect Speed", this.renderDisconnectSpeed());
+        writeTable("Unlisten Speed", this.renderUnlistenSpeed());
+        writeTitle("Bandwidth Report\n");
+        write(BANDWIDTH_NOTE + "\n\n");
+        writeTable("Downloaded Bytes", this.renderOutgoingBandwidth());
+        writeTable("Uploaded Bytes", this.renderIncomingBandwidth());
+        writeTable("Unindexed Queries", this.renderUnindexedData());
+    }
+    generateJson() {
+        return this.parse(this.processOperation.bind(this), this.outputJson.bind(this));
+    }
+    outputJson() {
+        const totalTime = this.state.endTime - this.state.startTime;
+        const tableToJson = (table, note) => {
+            const json = {
+                legend: table.options.head,
+                data: [],
+            };
+            if (note) {
+                json.note = note;
+            }
+            table.forEach((row) => {
+                json.data.push(row);
+            });
+            return json;
+        };
+        const json = {
+            totalTime: totalTime,
+            readSpeed: tableToJson(this.renderReadSpeed(), SPEED_NOTE),
+            writeSpeed: tableToJson(this.renderWriteSpeed(), SPEED_NOTE),
+            broadcastSpeed: tableToJson(this.renderBroadcastSpeed(), SPEED_NOTE),
+            connectSpeed: tableToJson(this.renderConnectSpeed(), SPEED_NOTE),
+            disconnectSpeed: tableToJson(this.renderDisconnectSpeed(), SPEED_NOTE),
+            unlistenSpeed: tableToJson(this.renderUnlistenSpeed(), SPEED_NOTE),
+            downloadedBytes: tableToJson(this.renderOutgoingBandwidth(), BANDWIDTH_NOTE),
+            uploadedBytes: tableToJson(this.renderIncomingBandwidth(), BANDWIDTH_NOTE),
+            unindexedQueries: tableToJson(this.renderUnindexedData()),
+        };
+        this.write(JSON.stringify(json, null, 2));
+        if (this.options.isFile) {
+            return this.output.path;
+        }
         return json;
-    };
-    var json = {
-        totalTime: totalTime,
-        readSpeed: tableToJson(this.renderReadSpeed(), SPEED_NOTE),
-        writeSpeed: tableToJson(this.renderWriteSpeed(), SPEED_NOTE),
-        broadcastSpeed: tableToJson(this.renderBroadcastSpeed(), SPEED_NOTE),
-        connectSpeed: tableToJson(this.renderConnectSpeed(), SPEED_NOTE),
-        disconnectSpeed: tableToJson(this.renderDisconnectSpeed(), SPEED_NOTE),
-        unlistenSpeed: tableToJson(this.renderUnlistenSpeed(), SPEED_NOTE),
-        downloadedBytes: tableToJson(this.renderOutgoingBandwidth(), BANDWIDTH_NOTE),
-        uploadedBytes: tableToJson(this.renderIncomingBandwidth(), BANDWIDTH_NOTE),
-        unindexedQueries: tableToJson(this.renderUnindexedData()),
-    };
-    this.write(JSON.stringify(json, null, 2));
-    if (this.options.isFile) {
-        return this.output.path;
-    }
-    return json;
-};
-module.exports = ProfileReport;
+    }
+}
+exports.ProfileReport = ProfileReport;