faastjs/dist/src/cost.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.CostAnalyzer = exports.CostSnapshot = exports.CostMetric = void 0;
const Listr = require("listr");
const util_1 = require("util");
const index_1 = require("../index");
const shared_1 = require("./shared");
const throttle_1 = require("./throttle");
/**
 * A line item in the cost estimate, including the resource usage metric
 * measured and its pricing.
 * @public
 */
class CostMetric {
    /** @internal */
    constructor(arg) {
        this.name = arg.name;
        this.pricing = arg.pricing;
        this.unit = arg.unit;
        this.measured = arg.measured;
        this.unitPlural = arg.unitPlural;
        this.comment = arg.comment;
        this.informationalOnly = arg.informationalOnly;
    }
    /**
     * The cost contribution of this cost metric. Equal to
     * {@link CostMetric.pricing} * {@link CostMetric.measured}.
     */
    cost() {
        return this.pricing * this.measured;
    }
    /**
     * Return a string with the cost estimate for this metric, omitting
     * comments.
     */
    describeCostOnly() {
        const p = (n, precision = 8) => Number.isInteger(n) ? String(n) : n.toFixed(precision);
        const getUnit = (n) => {
            if (n > 1) {
                return (this.unitPlural ||
                    (!this.unit.match(/[A-Z]$/) ? this.unit + "s" : this.unit));
            }
            else {
                return this.unit;
            }
        };
        const cost = `$${p(this.cost())}`;
        const pricing = `$${p(this.pricing)}/${this.unit}`;
        const metric = p(this.measured, this.unit === "second" ? 1 : 8);
        const unit = getUnit(this.measured);
        return `${this.name.padEnd(21)} ${pricing.padEnd(20)} ${metric.padStart(12)} ${unit.padEnd(10)} ${cost.padEnd(14)}`;
    }
    /** Describe this cost metric, including comments. */
    toString() {
        return `${this.describeCostOnly()}${(this.comment && `// ${this.comment}`) || ""}`;
    }
}
exports.CostMetric = CostMetric;
/**
 * A summary of the costs incurred by a faast.js module at a point in time.
 * Output of {@link FaastModule.costSnapshot}.
 * @remarks
 * Cost information provided by faast.js is an estimate. It is derived from
 * internal faast.js measurements and not by consulting data provided by your
 * cloud provider.
 *
 * **Faast.js does not guarantee the accuracy of cost estimates.**
 *
 * **Use at your own risk.**
 *
 * Example using AWS:
 * ```typescript
 * const faastModule = await faast("aws", m);
 * try {
 *     // Invoke faastModule.functions.*
 * } finally {
 *     await faastModule.cleanup();
 *     console.log(`Cost estimate:`);
 *     console.log(`${await faastModule.costSnapshot()}`);
 * }
 * ```
 *
 * AWS example output:
 * ```text
 * Cost estimate:
 * functionCallDuration  $0.00002813/second            0.6 second     $0.00001688    68.4%  [1]
 * sqs                   $0.00000040/request             9 requests   $0.00000360    14.6%  [2]
 * sns                   $0.00000050/request             5 requests   $0.00000250    10.1%  [3]
 * functionCallRequests  $0.00000020/request             5 requests   $0.00000100     4.1%  [4]
 * outboundDataTransfer  $0.09000000/GB         0.00000769 GB         $0.00000069     2.8%  [5]
 * logIngestion          $0.50000000/GB                  0 GB         $0              0.0%  [6]
 * ---------------------------------------------------------------------------------------
 *                                                                    $0.00002467 (USD)
 *
 *   * Estimated using highest pricing tier for each service. Limitations apply.
 *  ** Does not account for free tier.
 * [1]: https://aws.amazon.com/lambda/pricing (rate = 0.00001667/(GB*second) * 1.6875 GB = 0.00002813/second)
 * [2]: https://aws.amazon.com/sqs/pricing
 * [3]: https://aws.amazon.com/sns/pricing
 * [4]: https://aws.amazon.com/lambda/pricing
 * [5]: https://aws.amazon.com/ec2/pricing/on-demand/#Data_Transfer
 * [6]: https://aws.amazon.com/cloudwatch/pricing/ - Log ingestion costs not currently included.
 * ```
 *
 * A cost snapshot contains several {@link CostMetric} values. Each `CostMetric`
 * summarizes one component of the overall cost of executing the functions so
 * far. Some cost metrics are common to all faast providers, and other metrics
 * are provider-specific. The common metrics are:
 *
 * - `functionCallDuration`: the estimated billed CPU time (rounded to the next
 *   100ms) consumed by completed cloud function calls. This is the metric that
 *   usually dominates cost.
 *
 * - `functionCallRequests`: the number of invocation requests made. Most
 *   providers charge for each invocation.
 *
 * Provider-specific metrics vary. For example, AWS has the following additional
 * metrics:
 *
 * - `sqs`: AWS Simple Queueing Service. This metric captures the number of
 *   queue requests made to insert and retrieve queued results (each 64kb chunk
 *   is counted as an additional request). SQS is used even if
 *   {@link CommonOptions.mode} is not set to `"queue"`, because it is necessary
 *   for monitoring cloud function invocations.
 *
 * - `sns`: AWS Simple Notification Service. SNS is used to invoke Lambda
 *   functions when {@link CommonOptions.mode} is `"queue"`.
 *
 * - `outboundDataTransfer`: an estimate of the network data transferred out
 *   from the cloud provider for this faast.js module. This estimate only counts
 *   data returned from cloud function invocations and infrastructure that
 *   faast.js sets up. It does not count any outbound data sent by your cloud
 *   functions that are not known to faast.js. Note that if you run faast.js on
 *   EC2 in the same region (see {@link AwsOptions.region}), then the data
 *   transfer costs will be zero (however, the cost snapshot will not include
 *   EC2 costs). Also note that if your cloud function transfers data from/to S3
 *   buckets in the same region, there is no cost as long as that data is not
 *   returned from the function.
 *
 * - `logIngestion`: this cost metric is always zero for AWS. It is present to
 *   remind the user that AWS charges for log data ingested by CloudWatch Logs
 *   that are not measured by faast.js. Log entries may arrive significantly
 *   after function execution completes, and there is no way for faast.js to
 *   know exactly how long to wait, therefore it does not attempt to measure
 *   this cost. In practice, if your cloud functions do not perform extensive
 *   logging on all invocations, log ingestion costs from faast.js are likely to
 *   be low or fall within the free tier.
 *
 * For Google, extra metrics include `outboundDataTransfer` similar to AWS, and
 * `pubsub`, which combines costs that are split into `sns` and `sqs` on AWS.
 *
 * The Local provider has no extra metrics.
 *
 * Prices are retrieved dynamically from AWS and Google and cached locally.
 * Cached prices expire after 24h. For each cost metric, faast.js uses the
 * highest price tier to compute estimated pricing.
 *
 * Cost estimates do not take free tiers into account.
 * @public
 */
class CostSnapshot {
    /** @internal */
    constructor(
    /** The {@link Provider}, e.g. "aws" or "google" */
    provider, 
    /**
     * The options used to initialize the faast.js module where this cost
     * snapshot was generated.
     */
    options, stats, costMetrics = []) {
        this.provider = provider;
        this.options = options;
        /**
         * The cost metric components for this cost snapshot. See
         * {@link CostMetric}.
         */
        this.costMetrics = [];
        this.stats = stats.clone();
        this.costMetrics = [...costMetrics];
    }
    /** Sum of cost metrics. */
    total() {
        return (0, shared_1.sum)(this.costMetrics.map(metric => metric.cost()));
    }
    /** A summary of all cost metrics and prices in this cost snapshot. */
    toString() {
        let rv = "";
        this.costMetrics.sort((a, b) => b.cost() - a.cost());
        const total = this.total();
        const comments = [];
        const percent = (entry) => ((entry.cost() / total) * 100).toFixed(1).padStart(5) + "% ";
        for (const entry of this.costMetrics) {
            let commentIndex = "";
            if (entry.comment) {
                comments.push(entry.comment);
                commentIndex = ` [${comments.length}]`;
            }
            rv += `${entry.describeCostOnly()}${percent(entry)}${commentIndex}\n`;
        }
        rv +=
            "---------------------------------------------------------------------------------------\n";
        rv += `$${this.total().toFixed(8)}`.padStart(78) + " (USD)\n\n";
        rv += `  * Estimated using highest pricing tier for each service. Limitations apply.\n`;
        rv += ` ** Does not account for free tier.\n`;
        rv += comments.map((c, i) => `[${i + 1}]: ${c}`).join("\n");
        return rv;
    }
    /**
     * Comma separated value output for a cost snapshot.
     * @remarks
     * The format is "metric,unit,pricing,measured,cost,percentage,comment".
     *
     * Example output:
     * ```text
     * metric,unit,pricing,measured,cost,percentage,comment
     * functionCallDuration,second,0.00002813,0.60000000,0.00001688,64.1% ,"https://aws.amazon.com/lambda/pricing (rate = 0.00001667/(GB*second) * 1.6875 GB = 0.00002813/second)"
     * functionCallRequests,request,0.00000020,5,0.00000100,3.8% ,"https://aws.amazon.com/lambda/pricing"
     * outboundDataTransfer,GB,0.09000000,0.00000844,0.00000076,2.9% ,"https://aws.amazon.com/ec2/pricing/on-demand/#Data_Transfer"
     * sqs,request,0.00000040,13,0.00000520,19.7% ,"https://aws.amazon.com/sqs/pricing"
     * sns,request,0.00000050,5,0.00000250,9.5% ,"https://aws.amazon.com/sns/pricing"
     * logIngestion,GB,0.50000000,0,0,0.0% ,"https://aws.amazon.com/cloudwatch/pricing/ - Log ingestion costs not currently included."
     * ```
     */
    csv() {
        let rv = "";
        rv += "metric,unit,pricing,measured,cost,percentage,comment\n";
        const total = this.total();
        const p = (n) => (Number.isInteger(n) ? n : n.toFixed(8));
        const percent = (entry) => ((entry.cost() / total) * 100).toFixed(1) + "% ";
        for (const entry of this.costMetrics) {
            rv += `${entry.name},${entry.unit},${p(entry.pricing)},${p(entry.measured)},${p(entry.cost())},${percent(entry)},"${(entry.comment || "").replace('"', '""')}"\n`;
        }
        return rv;
    }
    /** @internal */
    push(metric) {
        this.costMetrics.push(metric);
    }
    /**
     * Find a specific cost metric by name.
     * @returns a {@link CostMetric} if found, otherwise `undefined`.
     */
    find(name) {
        return this.costMetrics.find(m => m.name === name);
    }
}
exports.CostSnapshot = CostSnapshot;
/**
 * Analyze the cost of a workload across many provider configurations.
 * @public
 */
var CostAnalyzer;
(function (CostAnalyzer) {
    /**
     * Default AWS cost analyzer configurations include all memory sizes for AWS
     * Lambda.
     * @remarks
     * The default AWS cost analyzer configurations include every memory size
     * from 128MB to 3008MB in 64MB increments. Each configuration has the
     * following settings:
     *
     * ```typescript
     * {
     *     provider: "aws",
     *     options: {
     *         mode: "https",
     *         memorySize,
     *         timeout: 300,
     *         gc: "off",
     *         childProcess: true
     *     }
     * }
     * ```
     *
     * Use `Array.map` to change or `Array.filter` to remove some of these
     * configurations. For example:
     *
     * ```typescript
     * const configsWithAtLeast1GB = awsConfigurations.filter(c => c.memorySize > 1024)
     * const shorterTimeout = awsConfigurations.map(c => ({...c, timeout: 60 }));
     * ```
     * @public
     */
    CostAnalyzer.awsConfigurations = (() => {
        const rv = [];
        for (let memorySize = 128; memorySize <= 3008; memorySize += 64) {
            rv.push({
                provider: "aws",
                options: {
                    mode: "https",
                    memorySize,
                    timeout: 300,
                    gc: "off",
                    childProcess: true
                }
            });
        }
        return rv;
    })();
    /**
     * Default Google Cloud Functions cost analyzer configurations include all
     * available memory sizes.
     * @remarks
     * Each google cost analyzer configuration follows this template:
     *
     * ```typescript
     * {
     *     provider: "google",
     *     options: {
     *         mode: "https",
     *         memorySize,
     *         timeout: 300,
     *         gc: "off",
     *         childProcess: true
     *     }
     * }
     * ```
     *
     * where `memorySize` is in `[128, 256, 512, 1024, 2048]`.
     * @public
     */
    CostAnalyzer.googleConfigurations = (() => {
        const rv = [];
        for (const memorySize of [128, 256, 512, 1024, 2048]) {
            rv.push({
                provider: "google",
                options: {
                    mode: "https",
                    memorySize,
                    timeout: 300,
                    gc: "off",
                    childProcess: true
                }
            });
        }
        return rv;
    })();
    const workloadDefaults = {
        configurations: CostAnalyzer.awsConfigurations,
        summarize: summarizeMean,
        format: defaultFormat,
        formatCSV: defaultFormatCSV,
        silent: false,
        repetitions: 10,
        concurrency: 64
    };
    function defaultFormat(attr, value) {
        return `${attr}:${(0, shared_1.f1)(value)}`;
    }
    function defaultFormatCSV(_, value) {
        return (0, shared_1.f1)(value);
    }
    const ps = (n) => (n / 1000).toFixed(3);
    function summarizeMean(attributes) {
        const stats = {};
        attributes.forEach(a => (0, shared_1.keysOf)(a).forEach(attr => {
            if (!(attr in stats)) {
                stats[attr] = new shared_1.Statistics();
            }
            stats[attr].update(a[attr]);
        }));
        const result = {};
        (0, shared_1.keysOf)(stats).forEach(attr => {
            result[attr] = stats[attr].mean;
        });
        return result;
    }
    async function estimate(workload, config) {
        const { provider, options } = config;
        const faastModule = await (0, index_1.faast)(provider, workload.funcs, options);
        const { repetitions, concurrency: repetitionConcurrency } = workload;
        const doWork = (0, throttle_1.throttle)({ concurrency: repetitionConcurrency }, workload.work);
        const results = [];
        for (let i = 0; i < repetitions; i++) {
            results.push(doWork(faastModule).catch(_ => { }));
        }
        const rv = (await Promise.all(results)).filter(r => r);
        await faastModule.cleanup();
        const costSnapshot = await faastModule.costSnapshot();
        const extraMetrics = workload.summarize(rv);
        return { costSnapshot, config, extraMetrics };
    }
    /**
     * Estimate the cost of a workload using multiple configurations and
     * providers.
     * @param userWorkload - a {@link CostAnalyzer.Workload} object specifying
     * the workload to run and additional parameters.
     * @returns A promise for a {@link CostAnalyzer.Result}
     * @public
     * @remarks
     * It can be deceptively difficult to set optimal parameters for AWS Lambda
     * and similar services. On the surface there appears to be only one
     * parameter: memory size. Choosing more memory also gives more CPU
     * performance, but it's unclear how much. It's also unclear where single
     * core performance stops getting better. The workload cost analyzer solves
     * these problems by making it easy to run cost experiments.
     * ```text
     *                                                      (AWS)
     *                                                    ┌───────┐
     *                                              ┌────▶│ 128MB │
     *                                              │     └───────┘
     *                                              │     ┌───────┐
     *                      ┌─────────────────┐     ├────▶│ 256MB │
     *  ┌──────────────┐    │                 │     │     └───────┘
     *  │   workload   │───▶│                 │     │        ...
     *  └──────────────┘    │                 │     │     ┌───────┐
     *                      │  cost analyzer  │─────┼────▶│3008MB │
     *  ┌──────────────┐    │                 │     │     └───────┘
     *  │configurations│───▶│                 │     │
     *  └──────────────┘    │                 │     │     (Google)
     *                      └─────────────────┘     │     ┌───────┐
     *                                              ├────▶│ 128MB │
     *                                              │     └───────┘
     *                                              │     ┌───────┐
     *                                              └────▶│ 256MB │
     *                                                    └───────┘
     * ```
     * `costAnalyzer` is the entry point. It automatically runs this workload
     * against multiple configurations in parallel. Then it uses faast.js' cost
     * snapshot mechanism to automatically determine the price of running the
     * workload with each configuration.
     *
     * Example:
     *
     * ```typescript
     * // functions.ts
     * export function randomNumbers(n: number) {
     *     let sum = 0;
     *     for (let i = 0; i < n; i++) {
     *         sum += Math.random();
     *     }
     *     return sum;
     * }
     *
     * // cost-analyzer-example.ts
     * import { writeFileSync } from "fs";
     * import { CostAnalyzer, FaastModule } from "faastjs";
     * import * as funcs from "./functions";
     *
     * async function work(faastModule: FaastModule<typeof funcs>) {
     *     await faastModule.functions.randomNumbers(100000000);
     * }
     *
     * async function main() {
     *     const results = await CostAnalyzer.analyze({ funcs, work });
     *     writeFileSync("cost.csv", results.csv());
     * }
     *
     * main();
     * ```
     *
     * Example output (this is printed to `console.log` unless the
     * {@link CostAnalyzer.Workload.silent} is `true`):
     * ```text
     *   ✔ aws 128MB queue 15.385s 0.274σ $0.00003921
     *   ✔ aws 192MB queue 10.024s 0.230σ $0.00003576
     *   ✔ aws 256MB queue 8.077s 0.204σ $0.00003779
     *      ▲    ▲     ▲     ▲       ▲        ▲
     *      │    │     │     │       │        │
     *  provider │    mode   │     stdev     average
     *           │           │   execution  estimated
     *         memory        │     time       cost
     *          size         │
     *                 average cloud
     *                 execution time
     * ```
     *
     * The output lists the provider, memory size, ({@link CommonOptions.mode}),
     * average time of a single execution of the workload, the standard
     * deviation (in seconds) of the execution time, and average estimated cost
     * for a single run of the workload.
     *
     * The "execution time" referenced here is not wall clock time, but rather
     * execution time in the cloud function. The execution time does not include
     * any time the workload spends waiting locally. If the workload invokes
     * multiple cloud functions, their execution times will be summed even if
     * they happen concurrently. This ensures the execution time and cost are
     * aligned.
     */
    async function analyze(userWorkload) {
        const scheduleEstimate = (0, throttle_1.throttle)({
            concurrency: 8,
            rate: 4,
            burst: 1,
            retry: 3
        }, estimate);
        const { concurrency = workloadDefaults.concurrency } = userWorkload;
        const workload = {
            ...workloadDefaults,
            ...userWorkload,
            work: (0, throttle_1.throttle)({ concurrency }, userWorkload.work)
        };
        const { configurations } = workload;
        const promises = configurations.map(config => scheduleEstimate(workload, config));
        const format = workload.format || defaultFormat;
        const renderer = workload.silent ? "silent" : "default";
        const list = new Listr(promises.map((promise, i) => {
            const { provider, options } = configurations[i];
            const { memorySize, mode } = options;
            return {
                title: `${provider} ${memorySize}MB ${mode}`,
                task: async (_, task) => {
                    const { costSnapshot, extraMetrics } = await promise;
                    const total = (costSnapshot.total() / workload.repetitions).toFixed(8);
                    const { errors } = costSnapshot.stats;
                    const { executionTime } = costSnapshot.stats;
                    const message = `${ps(executionTime.mean)}s ${ps(executionTime.stdev)}σ $${total}`;
                    const errMessage = errors > 0 ? ` (${errors} errors)` : "";
                    const extra = (0, shared_1.keysOf)(extraMetrics)
                        .map(k => format(k, extraMetrics[k]))
                        .join(" ");
                    task.title = `${task.title} ${message}${errMessage} ${extra}`;
                }
            };
        }), { concurrent: 8, nonTTYRenderer: renderer, renderer });
        await list.run();
        const results = await Promise.all(promises);
        results.sort((a, b) => a.costSnapshot.options.memorySize - b.costSnapshot.options.memorySize);
        return new Result(workload, results);
    }
    CostAnalyzer.analyze = analyze;
    /**
     * Cost analyzer results for each workload and configuration.
     * @remarks
     * The `estimates` property has the cost estimates for each configuration.
     * See {@link CostAnalyzer.Estimate}.
     * @public
     */
    class Result {
        /** @internal */
        constructor(
        /** The workload analyzed. */
        workload, 
        /**
         * Cost estimates for each configuration of the workload. See
         * {@link CostAnalyzer.Estimate}.
         */
        estimates) {
            this.workload = workload;
            this.estimates = estimates;
        }
        /**
         * Comma-separated output of cost analyzer. One line per cost analyzer
         * configuration.
         * @remarks
         * The columns are:
         *
         * - `memory`: The memory size allocated.
         *
         * - `cloud`: The cloud provider.
         *
         * - `mode`: See {@link CommonOptions.mode}.
         *
         * - `options`: A string summarizing other faast.js options applied to the
         *   `workload`. See {@link CommonOptions}.
         *
         * - `completed`: Number of repetitions that successfully completed.
         *
         * - `errors`: Number of invocations that failed.
         *
         * - `retries`: Number of retries that were attempted.
         *
         * - `cost`: The average cost of executing the workload once.
         *
         * - `executionTime`: the aggregate time spent executing on the provider for
         *   all cloud function invocations in the workload. This is averaged across
         *   repetitions.
         *
         * - `executionTimeStdev`: The standard deviation of `executionTime`.
         *
         * - `billedTime`: the same as `exectionTime`, except rounded up to the next
         *   100ms for each invocation. Usually very close to `executionTime`.
         */
        csv() {
            const attributes = new Set();
            this.estimates.forEach(est => (0, shared_1.keysOf)(est.extraMetrics).forEach(key => attributes.add(key)));
            const columns = [
                "memory",
                "cloud",
                "mode",
                "options",
                "completed",
                "errors",
                "retries",
                "cost",
                "executionTime",
                "executionTimeStdev",
                "billedTime",
                ...attributes
            ];
            let rv = columns.join(",") + "\n";
            this.estimates.forEach(({ costSnapshot, extraMetrics }) => {
                const { memorySize, mode, ...rest } = costSnapshot.options;
                const options = `"${(0, util_1.inspect)(rest).replace('"', '""')}"`;
                const { completed, errors, retries, executionTime, estimatedBilledTime } = costSnapshot.stats;
                const cost = (costSnapshot.total() / this.workload.repetitions).toFixed(8);
                const formatter = this.workload.formatCSV || defaultFormatCSV;
                const metrics = {};
                for (const attr of attributes) {
                    metrics[attr] = formatter(attr, extraMetrics[attr]);
                }
                const row = {
                    memory: memorySize,
                    cloud: costSnapshot.provider,
                    mode,
                    options,
                    completed,
                    errors,
                    retries,
                    cost: `$${cost}`,
                    executionTime: ps(executionTime.mean),
                    executionTimeStdev: ps(executionTime.stdev),
                    billedTime: ps(estimatedBilledTime.mean),
                    ...metrics
                };
                rv += (0, shared_1.keysOf)(row)
                    .map(k => String(row[k]))
                    .join(",");
                rv += "\n";
            });
            return rv;
        }
    }
    CostAnalyzer.Result = Result;
})(CostAnalyzer = exports.CostAnalyzer || (exports.CostAnalyzer = {}));
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cost.js","sourceRoot":"","sources":["../../src/cost.ts"],"names":[],"mappings":"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","sourcesContent":["import * as Listr from \"listr\";\nimport { inspect } from \"util\";\nimport { faast, FaastModule } from \"../index\";\nimport { AwsOptions } from \"./aws/aws-faast\";\nimport { GoogleOptions } from \"./google/google-faast\";\nimport { FunctionStats, CommonOptions } from \"./provider\";\nimport { f1, keysOf, Statistics, sum } from \"./shared\";\nimport { throttle } from \"./throttle\";\nimport { PropertiesExcept, AnyFunction } from \"./types\";\n\n/**\n * A line item in the cost estimate, including the resource usage metric\n * measured and its pricing.\n * @public\n */\nexport class CostMetric {\n    /** The name of the cost metric, e.g. `functionCallDuration` */\n    readonly name: string;\n    /** The price in USD per unit measured. */\n    readonly pricing: number;\n    /** The name of the units that pricing is measured in for this metric. */\n    readonly unit: string;\n    /** The measured value of the cost metric, in units. */\n    readonly measured: number;\n    /**\n     * The plural form of the unit name. By default the plural form will be the\n     * name of the unit with \"s\" appended at the end, unless the last letter is\n     * capitalized, in which case there is no plural form (e.g. \"GB\").\n     */\n    readonly unitPlural?: string;\n    /**\n     * An optional comment, usually providing a link to the provider's pricing\n     * page and other data.\n     */\n    readonly comment?: string;\n    /**\n     * True if this cost metric is only for informational purposes (e.g. AWS's\n     * `logIngestion`) and does not contribute cost.\n     */\n    readonly informationalOnly?: boolean;\n\n    /** @internal */\n    constructor(arg: PropertiesExcept<CostMetric, AnyFunction>) {\n        this.name = arg.name;\n        this.pricing = arg.pricing;\n        this.unit = arg.unit;\n        this.measured = arg.measured;\n        this.unitPlural = arg.unitPlural;\n        this.comment = arg.comment;\n        this.informationalOnly = arg.informationalOnly;\n    }\n\n    /**\n     * The cost contribution of this cost metric. Equal to\n     * {@link CostMetric.pricing} * {@link CostMetric.measured}.\n     */\n    cost() {\n        return this.pricing * this.measured;\n    }\n\n    /**\n     * Return a string with the cost estimate for this metric, omitting\n     * comments.\n     */\n    describeCostOnly() {\n        const p = (n: number, precision = 8) =>\n            Number.isInteger(n) ? String(n) : n.toFixed(precision);\n        const getUnit = (n: number) => {\n            if (n > 1) {\n                return (\n                    this.unitPlural ||\n                    (!this.unit.match(/[A-Z]$/) ? this.unit + \"s\" : this.unit)\n                );\n            } else {\n                return this.unit;\n            }\n        };\n\n        const cost = `$${p(this.cost())}`;\n        const pricing = `$${p(this.pricing)}/${this.unit}`;\n        const metric = p(this.measured, this.unit === \"second\" ? 1 : 8);\n        const unit = getUnit(this.measured);\n\n        return `${this.name.padEnd(21)} ${pricing.padEnd(20)} ${metric.padStart(\n            12\n        )} ${unit.padEnd(10)} ${cost.padEnd(14)}`;\n    }\n\n    /** Describe this cost metric, including comments. */\n    toString() {\n        return `${this.describeCostOnly()}${\n            (this.comment && `// ${this.comment}`) || \"\"\n        }`;\n    }\n}\n\n/**\n * A summary of the costs incurred by a faast.js module at a point in time.\n * Output of {@link FaastModule.costSnapshot}.\n * @remarks\n * Cost information provided by faast.js is an estimate. It is derived from\n * internal faast.js measurements and not by consulting data provided by your\n * cloud provider.\n *\n * **Faast.js does not guarantee the accuracy of cost estimates.**\n *\n * **Use at your own risk.**\n *\n * Example using AWS:\n * ```typescript\n * const faastModule = await faast(\"aws\", m);\n * try {\n *     // Invoke faastModule.functions.*\n * } finally {\n *     await faastModule.cleanup();\n *     console.log(`Cost estimate:`);\n *     console.log(`${await faastModule.costSnapshot()}`);\n * }\n * ```\n *\n * AWS example output:\n * ```text\n * Cost estimate:\n * functionCallDuration  $0.00002813/second            0.6 second     $0.00001688    68.4%  [1]\n * sqs                   $0.00000040/request             9 requests   $0.00000360    14.6%  [2]\n * sns                   $0.00000050/request             5 requests   $0.00000250    10.1%  [3]\n * functionCallRequests  $0.00000020/request             5 requests   $0.00000100     4.1%  [4]\n * outboundDataTransfer  $0.09000000/GB         0.00000769 GB         $0.00000069     2.8%  [5]\n * logIngestion          $0.50000000/GB                  0 GB         $0              0.0%  [6]\n * ---------------------------------------------------------------------------------------\n *                                                                    $0.00002467 (USD)\n *\n *   * Estimated using highest pricing tier for each service. Limitations apply.\n *  ** Does not account for free tier.\n * [1]: https://aws.amazon.com/lambda/pricing (rate = 0.00001667/(GB*second) * 1.6875 GB = 0.00002813/second)\n * [2]: https://aws.amazon.com/sqs/pricing\n * [3]: https://aws.amazon.com/sns/pricing\n * [4]: https://aws.amazon.com/lambda/pricing\n * [5]: https://aws.amazon.com/ec2/pricing/on-demand/#Data_Transfer\n * [6]: https://aws.amazon.com/cloudwatch/pricing/ - Log ingestion costs not currently included.\n * ```\n *\n * A cost snapshot contains several {@link CostMetric} values. Each `CostMetric`\n * summarizes one component of the overall cost of executing the functions so\n * far. Some cost metrics are common to all faast providers, and other metrics\n * are provider-specific. The common metrics are:\n *\n * - `functionCallDuration`: the estimated billed CPU time (rounded to the next\n *   100ms) consumed by completed cloud function calls. This is the metric that\n *   usually dominates cost.\n *\n * - `functionCallRequests`: the number of invocation requests made. Most\n *   providers charge for each invocation.\n *\n * Provider-specific metrics vary. For example, AWS has the following additional\n * metrics:\n *\n * - `sqs`: AWS Simple Queueing Service. This metric captures the number of\n *   queue requests made to insert and retrieve queued results (each 64kb chunk\n *   is counted as an additional request). SQS is used even if\n *   {@link CommonOptions.mode} is not set to `\"queue\"`, because it is necessary\n *   for monitoring cloud function invocations.\n *\n * - `sns`: AWS Simple Notification Service. SNS is used to invoke Lambda\n *   functions when {@link CommonOptions.mode} is `\"queue\"`.\n *\n * - `outboundDataTransfer`: an estimate of the network data transferred out\n *   from the cloud provider for this faast.js module. This estimate only counts\n *   data returned from cloud function invocations and infrastructure that\n *   faast.js sets up. It does not count any outbound data sent by your cloud\n *   functions that are not known to faast.js. Note that if you run faast.js on\n *   EC2 in the same region (see {@link AwsOptions.region}), then the data\n *   transfer costs will be zero (however, the cost snapshot will not include\n *   EC2 costs). Also note that if your cloud function transfers data from/to S3\n *   buckets in the same region, there is no cost as long as that data is not\n *   returned from the function.\n *\n * - `logIngestion`: this cost metric is always zero for AWS. It is present to\n *   remind the user that AWS charges for log data ingested by CloudWatch Logs\n *   that are not measured by faast.js. Log entries may arrive significantly\n *   after function execution completes, and there is no way for faast.js to\n *   know exactly how long to wait, therefore it does not attempt to measure\n *   this cost. In practice, if your cloud functions do not perform extensive\n *   logging on all invocations, log ingestion costs from faast.js are likely to\n *   be low or fall within the free tier.\n *\n * For Google, extra metrics include `outboundDataTransfer` similar to AWS, and\n * `pubsub`, which combines costs that are split into `sns` and `sqs` on AWS.\n *\n * The Local provider has no extra metrics.\n *\n * Prices are retrieved dynamically from AWS and Google and cached locally.\n * Cached prices expire after 24h. For each cost metric, faast.js uses the\n * highest price tier to compute estimated pricing.\n *\n * Cost estimates do not take free tiers into account.\n * @public\n */\nexport class CostSnapshot {\n    /** The function statistics that were used to compute prices. */\n    readonly stats: FunctionStats;\n    /**\n     * The cost metric components for this cost snapshot. See\n     * {@link CostMetric}.\n     */\n    readonly costMetrics: CostMetric[] = [];\n    /** @internal */\n    constructor(\n        /** The {@link Provider}, e.g. \"aws\" or \"google\" */\n        readonly provider: string,\n        /**\n         * The options used to initialize the faast.js module where this cost\n         * snapshot was generated.\n         */\n        readonly options: CommonOptions | AwsOptions | GoogleOptions,\n        stats: FunctionStats,\n        costMetrics: CostMetric[] = []\n    ) {\n        this.stats = stats.clone();\n        this.costMetrics = [...costMetrics];\n    }\n\n    /** Sum of cost metrics. */\n    total() {\n        return sum(this.costMetrics.map(metric => metric.cost()));\n    }\n\n    /** A summary of all cost metrics and prices in this cost snapshot. */\n    toString() {\n        let rv = \"\";\n        this.costMetrics.sort((a, b) => b.cost() - a.cost());\n        const total = this.total();\n        const comments = [];\n        const percent = (entry: CostMetric) =>\n            ((entry.cost() / total) * 100).toFixed(1).padStart(5) + \"% \";\n        for (const entry of this.costMetrics) {\n            let commentIndex = \"\";\n            if (entry.comment) {\n                comments.push(entry.comment);\n                commentIndex = ` [${comments.length}]`;\n            }\n            rv += `${entry.describeCostOnly()}${percent(entry)}${commentIndex}\\n`;\n        }\n        rv +=\n            \"---------------------------------------------------------------------------------------\\n\";\n        rv += `$${this.total().toFixed(8)}`.padStart(78) + \" (USD)\\n\\n\";\n        rv += `  * Estimated using highest pricing tier for each service. Limitations apply.\\n`;\n        rv += ` ** Does not account for free tier.\\n`;\n        rv += comments.map((c, i) => `[${i + 1}]: ${c}`).join(\"\\n\");\n        return rv;\n    }\n\n    /**\n     * Comma separated value output for a cost snapshot.\n     * @remarks\n     * The format is \"metric,unit,pricing,measured,cost,percentage,comment\".\n     *\n     * Example output:\n     * ```text\n     * metric,unit,pricing,measured,cost,percentage,comment\n     * functionCallDuration,second,0.00002813,0.60000000,0.00001688,64.1% ,\"https://aws.amazon.com/lambda/pricing (rate = 0.00001667/(GB*second) * 1.6875 GB = 0.00002813/second)\"\n     * functionCallRequests,request,0.00000020,5,0.00000100,3.8% ,\"https://aws.amazon.com/lambda/pricing\"\n     * outboundDataTransfer,GB,0.09000000,0.00000844,0.00000076,2.9% ,\"https://aws.amazon.com/ec2/pricing/on-demand/#Data_Transfer\"\n     * sqs,request,0.00000040,13,0.00000520,19.7% ,\"https://aws.amazon.com/sqs/pricing\"\n     * sns,request,0.00000050,5,0.00000250,9.5% ,\"https://aws.amazon.com/sns/pricing\"\n     * logIngestion,GB,0.50000000,0,0,0.0% ,\"https://aws.amazon.com/cloudwatch/pricing/ - Log ingestion costs not currently included.\"\n     * ```\n     */\n    csv() {\n        let rv = \"\";\n        rv += \"metric,unit,pricing,measured,cost,percentage,comment\\n\";\n        const total = this.total();\n        const p = (n: number) => (Number.isInteger(n) ? n : n.toFixed(8));\n        const percent = (entry: CostMetric) =>\n            ((entry.cost() / total) * 100).toFixed(1) + \"% \";\n        for (const entry of this.costMetrics) {\n            rv += `${entry.name},${entry.unit},${p(entry.pricing)},${p(\n                entry.measured\n            )},${p(entry.cost())},${percent(entry)},\"${(entry.comment || \"\").replace(\n                '\"',\n                '\"\"'\n            )}\"\\n`;\n        }\n        return rv;\n    }\n\n    /** @internal */\n    push(metric: CostMetric) {\n        this.costMetrics.push(metric);\n    }\n\n    /**\n     * Find a specific cost metric by name.\n     * @returns a {@link CostMetric} if found, otherwise `undefined`.\n     */\n    find(name: string) {\n        return this.costMetrics.find(m => m.name === name);\n    }\n}\n\n/**\n * Analyze the cost of a workload across many provider configurations.\n * @public\n */\nexport namespace CostAnalyzer {\n    /**\n     * An input to {@link CostAnalyzer.analyze}, specifying one\n     * configuration of faast.js to run against a workload. See\n     * {@link AwsOptions} and {@link GoogleOptions}.\n     * @public\n     */\n    export type Configuration =\n        | {\n              provider: \"aws\";\n              options: AwsOptions;\n          }\n        | {\n              provider: \"google\";\n              options: GoogleOptions;\n          };\n\n    /**\n     * Default AWS cost analyzer configurations include all memory sizes for AWS\n     * Lambda.\n     * @remarks\n     * The default AWS cost analyzer configurations include every memory size\n     * from 128MB to 3008MB in 64MB increments. Each configuration has the\n     * following settings:\n     *\n     * ```typescript\n     * {\n     *     provider: \"aws\",\n     *     options: {\n     *         mode: \"https\",\n     *         memorySize,\n     *         timeout: 300,\n     *         gc: \"off\",\n     *         childProcess: true\n     *     }\n     * }\n     * ```\n     *\n     * Use `Array.map` to change or `Array.filter` to remove some of these\n     * configurations. For example:\n     *\n     * ```typescript\n     * const configsWithAtLeast1GB = awsConfigurations.filter(c => c.memorySize > 1024)\n     * const shorterTimeout = awsConfigurations.map(c => ({...c, timeout: 60 }));\n     * ```\n     * @public\n     */\n    export const awsConfigurations: Configuration[] = (() => {\n        const rv: Configuration[] = [];\n        for (let memorySize = 128; memorySize <= 3008; memorySize += 64) {\n            rv.push({\n                provider: \"aws\",\n                options: {\n                    mode: \"https\",\n                    memorySize,\n                    timeout: 300,\n                    gc: \"off\",\n                    childProcess: true\n                }\n            });\n        }\n        return rv;\n    })();\n\n    /**\n     * Default Google Cloud Functions cost analyzer configurations include all\n     * available memory sizes.\n     * @remarks\n     * Each google cost analyzer configuration follows this template:\n     *\n     * ```typescript\n     * {\n     *     provider: \"google\",\n     *     options: {\n     *         mode: \"https\",\n     *         memorySize,\n     *         timeout: 300,\n     *         gc: \"off\",\n     *         childProcess: true\n     *     }\n     * }\n     * ```\n     *\n     * where `memorySize` is in `[128, 256, 512, 1024, 2048]`.\n     * @public\n     */\n    export const googleConfigurations: Configuration[] = (() => {\n        const rv: Configuration[] = [];\n        for (const memorySize of [128, 256, 512, 1024, 2048]) {\n            rv.push({\n                provider: \"google\",\n                options: {\n                    mode: \"https\",\n                    memorySize,\n                    timeout: 300,\n                    gc: \"off\",\n                    childProcess: true\n                }\n            });\n        }\n        return rv;\n    })();\n\n    /**\n     * User-defined custom metrics for a workload. These are automatically\n     * summarized in the output; see {@link CostAnalyzer.Workload}.\n     * @public\n     */\n    export type WorkloadAttribute<A extends string> = { [attr in A]: number };\n\n    /**\n     * A user-defined cost analyzer workload for {@link CostAnalyzer.analyze}.\n     * @public\n     * Example:\n     */\n    export interface Workload<T extends object, A extends string> {\n        /**\n         * The imported module that contains the cloud functions to test.\n         */\n        funcs: T;\n        /**\n         * A function that executes cloud functions on\n         * `faastModule.functions.*`. The work function should return `void` if\n         * there are no custom workload attributes. Otherwise, it should return\n         * a {@link CostAnalyzer.WorkloadAttribute} object which maps\n         * user-defined attribute names to numerical values for the workload.\n         * For example, this might measure bandwidth or some other metric not\n         * tracked by faast.js, but are relevant for evaluating the\n         * cost-performance tradeoff of the configurations analyzed by the cost\n         * analyzer.\n         */\n        work: (faastModule: FaastModule<T>) => Promise<WorkloadAttribute<A> | void>;\n        /**\n         * An array of configurations to run the work function against (see\n         * {@link CostAnalyzer.Configuration}). For example, each entry in the\n         * array may specify a provider, memory size, and other options.\n         * Default: {@link CostAnalyzer.awsConfigurations}.\n         */\n        configurations?: Configuration[];\n        /**\n         * Combine {@link CostAnalyzer.WorkloadAttribute} instances returned\n         * from multiple workload executions (caused by value of\n         * {@link CostAnalyzer.Workload.repetitions}). The default is a function\n         * that takes the average of each attribute.\n         */\n        summarize?: (summaries: WorkloadAttribute<A>[]) => WorkloadAttribute<A>;\n        /**\n         * Format an attribute value for console output. This is displayed by\n         * the cost analyzer when all of the repetitions for a configuration\n         * have completed. The default returns\n         * `${attribute}:${value.toFixed(1)}`.\n         */\n        format?: (attr: A, value: number) => string;\n        /**\n         * Format an attribute value for CSV. The default returns\n         * `value.toFixed(1)`.\n         */\n        formatCSV?: (attr: A, value: number) => string;\n        /**\n         * If true, do not output live results to the console. Can be useful for\n         * running the cost analyzer as part of automated tests. Default: false.\n         */\n        silent?: boolean;\n        /**\n         * The number of repetitions to run the workload for each cost analyzer\n         * configuration. Higher repetitions help reduce the jitter in the\n         * results. Repetitions execute in the same FaastModule instance.\n         * Default: 10.\n         */\n        repetitions?: number;\n        /**\n         * The amount of concurrency to allow. Concurrency can arise from\n         * multiple repetitions of the same configuration, or concurrenct\n         * executions of different configurations. This concurrency limit\n         * throttles the total number of concurrent workload executions across\n         * both of these sources of concurrency. Default: 64.\n         */\n        concurrency?: number;\n    }\n\n    const workloadDefaults = {\n        configurations: awsConfigurations,\n        summarize: summarizeMean,\n        format: defaultFormat,\n        formatCSV: defaultFormatCSV,\n        silent: false,\n        repetitions: 10,\n        concurrency: 64\n    };\n\n    function defaultFormat(attr: string, value: number) {\n        return `${attr}:${f1(value)}`;\n    }\n\n    function defaultFormatCSV(_: string, value: number) {\n        return f1(value);\n    }\n\n    const ps = (n: number) => (n / 1000).toFixed(3);\n\n    function summarizeMean<A extends string>(attributes: WorkloadAttribute<A>[]) {\n        const stats: { [attr: string]: Statistics } = {};\n        attributes.forEach(a =>\n            keysOf(a).forEach(attr => {\n                if (!(attr in stats)) {\n                    stats[attr] = new Statistics();\n                }\n                stats[attr].update(a[attr]);\n            })\n        );\n        const result = {} as any;\n        keysOf(stats).forEach(attr => {\n            result[attr] = stats[attr].mean;\n        });\n        return result;\n    }\n\n    /**\n     * A cost estimate result for a specific cost analyzer configuration.\n     * @public\n     */\n    export interface Estimate<A extends string> {\n        /**\n         * The cost snapshot for the cost analysis of the specific (workload,\n         * configuration) combination. See {@link CostSnapshot}.\n         */\n        costSnapshot: CostSnapshot;\n        /**\n         * The worload configuration that was analyzed. See\n         * {@link CostAnalyzer.Configuration}.\n         */\n        config: Configuration;\n        /**\n         * Additional workload metrics returned from the work function. See\n         * {@link CostAnalyzer.WorkloadAttribute}.\n         */\n        extraMetrics: WorkloadAttribute<A>;\n    }\n\n    async function estimate<T extends object, K extends string>(\n        workload: Required<Workload<T, K>>,\n        config: Configuration\n    ): Promise<Estimate<K>> {\n        const { provider, options } = config;\n        const faastModule = await faast(provider, workload.funcs, options);\n        const { repetitions, concurrency: repetitionConcurrency } = workload;\n        const doWork = throttle({ concurrency: repetitionConcurrency }, workload.work);\n        const results: Promise<WorkloadAttribute<K> | void>[] = [];\n        for (let i = 0; i < repetitions; i++) {\n            results.push(doWork(faastModule).catch(_ => {}));\n        }\n        const rv = (await Promise.all(results)).filter(r => r) as WorkloadAttribute<K>[];\n        await faastModule.cleanup();\n        const costSnapshot = await faastModule.costSnapshot();\n        const extraMetrics = workload.summarize(rv);\n        return { costSnapshot, config, extraMetrics };\n    }\n\n    /**\n     * Estimate the cost of a workload using multiple configurations and\n     * providers.\n     * @param userWorkload - a {@link CostAnalyzer.Workload} object specifying\n     * the workload to run and additional parameters.\n     * @returns A promise for a {@link CostAnalyzer.Result}\n     * @public\n     * @remarks\n     * It can be deceptively difficult to set optimal parameters for AWS Lambda\n     * and similar services. On the surface there appears to be only one\n     * parameter: memory size. Choosing more memory also gives more CPU\n     * performance, but it's unclear how much. It's also unclear where single\n     * core performance stops getting better. The workload cost analyzer solves\n     * these problems by making it easy to run cost experiments.\n     * ```text\n     *                                                      (AWS)\n     *                                                    ┌───────┐\n     *                                              ┌────▶│ 128MB │\n     *                                              │     └───────┘\n     *                                              │     ┌───────┐\n     *                      ┌─────────────────┐     ├────▶│ 256MB │\n     *  ┌──────────────┐    │                 │     │     └───────┘\n     *  │   workload   │───▶│                 │     │        ...\n     *  └──────────────┘    │                 │     │     ┌───────┐\n     *                      │  cost analyzer  │─────┼────▶│3008MB │\n     *  ┌──────────────┐    │                 │     │     └───────┘\n     *  │configurations│───▶│                 │     │\n     *  └──────────────┘    │                 │     │     (Google)\n     *                      └─────────────────┘     │     ┌───────┐\n     *                                              ├────▶│ 128MB │\n     *                                              │     └───────┘\n     *                                              │     ┌───────┐\n     *                                              └────▶│ 256MB │\n     *                                                    └───────┘\n     * ```\n     * `costAnalyzer` is the entry point. It automatically runs this workload\n     * against multiple configurations in parallel. Then it uses faast.js' cost\n     * snapshot mechanism to automatically determine the price of running the\n     * workload with each configuration.\n     *\n     * Example:\n     *\n     * ```typescript\n     * // functions.ts\n     * export function randomNumbers(n: number) {\n     *     let sum = 0;\n     *     for (let i = 0; i < n; i++) {\n     *         sum += Math.random();\n     *     }\n     *     return sum;\n     * }\n     *\n     * // cost-analyzer-example.ts\n     * import { writeFileSync } from \"fs\";\n     * import { CostAnalyzer, FaastModule } from \"faastjs\";\n     * import * as funcs from \"./functions\";\n     *\n     * async function work(faastModule: FaastModule<typeof funcs>) {\n     *     await faastModule.functions.randomNumbers(100000000);\n     * }\n     *\n     * async function main() {\n     *     const results = await CostAnalyzer.analyze({ funcs, work });\n     *     writeFileSync(\"cost.csv\", results.csv());\n     * }\n     *\n     * main();\n     * ```\n     *\n     * Example output (this is printed to `console.log` unless the\n     * {@link CostAnalyzer.Workload.silent} is `true`):\n     * ```text\n     *   ✔ aws 128MB queue 15.385s 0.274σ $0.00003921\n     *   ✔ aws 192MB queue 10.024s 0.230σ $0.00003576\n     *   ✔ aws 256MB queue 8.077s 0.204σ $0.00003779\n     *      ▲    ▲     ▲     ▲       ▲        ▲\n     *      │    │     │     │       │        │\n     *  provider │    mode   │     stdev     average\n     *           │           │   execution  estimated\n     *         memory        │     time       cost\n     *          size         │\n     *                 average cloud\n     *                 execution time\n     * ```\n     *\n     * The output lists the provider, memory size, ({@link CommonOptions.mode}),\n     * average time of a single execution of the workload, the standard\n     * deviation (in seconds) of the execution time, and average estimated cost\n     * for a single run of the workload.\n     *\n     * The \"execution time\" referenced here is not wall clock time, but rather\n     * execution time in the cloud function. The execution time does not include\n     * any time the workload spends waiting locally. If the workload invokes\n     * multiple cloud functions, their execution times will be summed even if\n     * they happen concurrently. This ensures the execution time and cost are\n     * aligned.\n     */\n    export async function analyze<T extends object, A extends string>(\n        userWorkload: Workload<T, A>\n    ) {\n        const scheduleEstimate = throttle<\n            [Required<Workload<T, A>>, Configuration],\n            Estimate<A>\n        >(\n            {\n                concurrency: 8,\n                rate: 4,\n                burst: 1,\n                retry: 3\n            },\n            estimate\n        );\n\n        const { concurrency = workloadDefaults.concurrency } = userWorkload;\n        const workload: Required<Workload<T, A>> = {\n            ...workloadDefaults,\n            ...userWorkload,\n            work: throttle({ concurrency }, userWorkload.work)\n        };\n\n        const { configurations } = workload;\n        const promises = configurations.map(config => scheduleEstimate(workload, config));\n\n        const format = workload.format || defaultFormat;\n\n        const renderer = workload.silent ? \"silent\" : \"default\";\n\n        const list = new Listr(\n            promises.map((promise, i) => {\n                const { provider, options } = configurations[i];\n                const { memorySize, mode } = options;\n\n                return {\n                    title: `${provider} ${memorySize}MB ${mode}`,\n                    task: async (_: any, task: Listr.ListrTaskWrapper) => {\n                        const { costSnapshot, extraMetrics } = await promise;\n                        const total = (\n                            costSnapshot.total() / workload.repetitions\n                        ).toFixed(8);\n                        const { errors } = costSnapshot.stats;\n                        const { executionTime } = costSnapshot.stats;\n                        const message = `${ps(executionTime.mean)}s ${ps(\n                            executionTime.stdev\n                        )}σ $${total}`;\n                        const errMessage = errors > 0 ? ` (${errors} errors)` : \"\";\n                        const extra = keysOf(extraMetrics)\n                            .map(k => format(k, extraMetrics[k]))\n                            .join(\" \");\n                        task.title = `${task.title} ${message}${errMessage} ${extra}`;\n                    }\n                };\n            }),\n            { concurrent: 8, nonTTYRenderer: renderer, renderer }\n        );\n\n        await list.run();\n        const results = await Promise.all(promises);\n        results.sort(\n            (a, b) =>\n                a.costSnapshot.options.memorySize! - b.costSnapshot.options.memorySize!\n        );\n        return new Result(workload, results);\n    }\n\n    /**\n     * Cost analyzer results for each workload and configuration.\n     * @remarks\n     * The `estimates` property has the cost estimates for each configuration.\n     * See {@link CostAnalyzer.Estimate}.\n     * @public\n     */\n    export class Result<T extends object, A extends string> {\n        /** @internal */\n        constructor(\n            /** The workload analyzed. */\n            readonly workload: Required<Workload<T, A>>,\n            /**\n             * Cost estimates for each configuration of the workload. See\n             * {@link CostAnalyzer.Estimate}.\n             */\n            readonly estimates: Estimate<A>[]\n        ) {}\n\n        /**\n         * Comma-separated output of cost analyzer. One line per cost analyzer\n         * configuration.\n         * @remarks\n         * The columns are:\n         *\n         * - `memory`: The memory size allocated.\n         *\n         * - `cloud`: The cloud provider.\n         *\n         * - `mode`: See {@link CommonOptions.mode}.\n         *\n         * - `options`: A string summarizing other faast.js options applied to the\n         *   `workload`. See {@link CommonOptions}.\n         *\n         * - `completed`: Number of repetitions that successfully completed.\n         *\n         * - `errors`: Number of invocations that failed.\n         *\n         * - `retries`: Number of retries that were attempted.\n         *\n         * - `cost`: The average cost of executing the workload once.\n         *\n         * - `executionTime`: the aggregate time spent executing on the provider for\n         *   all cloud function invocations in the workload. This is averaged across\n         *   repetitions.\n         *\n         * - `executionTimeStdev`: The standard deviation of `executionTime`.\n         *\n         * - `billedTime`: the same as `exectionTime`, except rounded up to the next\n         *   100ms for each invocation. Usually very close to `executionTime`.\n         */\n        csv() {\n            const attributes = new Set<A>();\n            this.estimates.forEach(est =>\n                keysOf(est.extraMetrics).forEach(key => attributes.add(key))\n            );\n            const columns = [\n                \"memory\",\n                \"cloud\",\n                \"mode\",\n                \"options\",\n                \"completed\",\n                \"errors\",\n                \"retries\",\n                \"cost\",\n                \"executionTime\",\n                \"executionTimeStdev\",\n                \"billedTime\",\n                ...attributes\n            ];\n            let rv = columns.join(\",\") + \"\\n\";\n\n            this.estimates.forEach(({ costSnapshot, extraMetrics }) => {\n                const { memorySize, mode, ...rest } = costSnapshot.options;\n                const options = `\"${inspect(rest).replace('\"', '\"\"')}\"`;\n                const { completed, errors, retries, executionTime, estimatedBilledTime } =\n                    costSnapshot.stats;\n                const cost = (costSnapshot.total() / this.workload.repetitions).toFixed(\n                    8\n                );\n                const formatter = this.workload.formatCSV || defaultFormatCSV;\n\n                const metrics: { [attr in string]: string } = {};\n                for (const attr of attributes) {\n                    metrics[attr] = formatter(attr, extraMetrics[attr]);\n                }\n                const row = {\n                    memory: memorySize,\n                    cloud: costSnapshot.provider,\n                    mode,\n                    options,\n                    completed,\n                    errors,\n                    retries,\n                    cost: `$${cost}`,\n                    executionTime: ps(executionTime.mean),\n                    executionTimeStdev: ps(executionTime.stdev),\n                    billedTime: ps(estimatedBilledTime.mean),\n                    ...metrics\n                };\n\n                rv += keysOf(row)\n                    .map(k => String(row[k]))\n                    .join(\",\");\n                rv += \"\\n\";\n            });\n            return rv;\n        }\n    }\n}\n"]}