@crawlee/core 3.0.0-alpha.2 → 3.0.0-alpha.3

package/dist/autoscaling/autoscaled_pool.js

@@ -0,0 +1,624 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoscaledPool = void 0;
+const tslib_1 = require("tslib");
+const timeout_1 = require("@apify/timeout");
+const utilities_1 = require("@apify/utilities");
+const ow_1 = tslib_1.__importDefault(require("ow"));
+const configuration_1 = require("../configuration");
+const log_1 = require("../log");
+const snapshotter_1 = require("./snapshotter");
+const system_status_1 = require("./system_status");
+/**
+ * Manages a pool of asynchronous resource-intensive tasks that are executed in parallel.
+ * The pool only starts new tasks if there is enough free CPU and memory available
+ * and the Javascript event loop is not blocked.
+ *
+ * The information about the CPU and memory usage is obtained by the {@link Snapshotter} class,
+ * which makes regular snapshots of system resources that may be either local
+ * or from the Apify cloud infrastructure in case the process is running on the Apify platform.
+ * Meaningful data gathered from these snapshots is provided to `AutoscaledPool` by the {@link SystemStatus} class.
+ *
+ * Before running the pool, you need to implement the following three functions:
+ * {@link AutoscaledPoolOptions.runTaskFunction},
+ * {@link AutoscaledPoolOptions.isTaskReadyFunction} and
+ * {@link AutoscaledPoolOptions.isFinishedFunction}.
+ *
+ * The auto-scaled pool is started by calling the {@link AutoscaledPool.run} function.
+ * The pool periodically queries the {@link AutoscaledPoolOptions.isTaskReadyFunction} function
+ * for more tasks, managing optimal concurrency, until the function resolves to `false`. The pool then queries
+ * the {@link AutoscaledPoolOptions.isFinishedFunction}. If it resolves to `true`, the run finishes after all running tasks complete.
+ * If it resolves to `false`, it assumes there will be more tasks available later and keeps periodically querying for tasks.
+ * If any of the tasks throws then the {@link AutoscaledPool.run} function rejects the promise with an error.
+ *
+ * The pool evaluates whether it should start a new task every time one of the tasks finishes
+ * and also in the interval set by the `options.maybeRunIntervalSecs` parameter.
+ *
+ * **Example usage:**
+ *
+ * ```javascript
+ * const pool = new AutoscaledPool({
+ *     maxConcurrency: 50,
+ *     runTaskFunction: async () => {
+ *         // Run some resource-intensive asynchronous operation here.
+ *     },
+ *     isTaskReadyFunction: async () => {
+ *         // Tell the pool whether more tasks are ready to be processed.
+ *         // Return true or false
+ *     },
+ *     isFinishedFunction: async () => {
+ *         // Tell the pool whether it should finish
+ *         // or wait for more tasks to become available.
+ *         // Return true or false
+ *     }
+ * });
+ *
+ * await pool.run();
+ * ```
+ * @category Scaling
+ */
+class AutoscaledPool {
+    constructor(options, config = configuration_1.Configuration.getGlobalConfig()) {
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: config
+        });
+        Object.defineProperty(this, "log", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Configurable properties.
+        Object.defineProperty(this, "desiredConcurrencyRatio", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "scaleUpStepRatio", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "scaleDownStepRatio", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "maybeRunIntervalMillis", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "loggingIntervalMillis", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "autoscaleIntervalMillis", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "taskTimeoutMillis", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "runTaskFunction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "isFinishedFunction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "isTaskReadyFunction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Internal properties.
+        Object.defineProperty(this, "_minConcurrency", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_maxConcurrency", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_desiredConcurrency", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_currentConcurrency", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "isStopped", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "lastLoggingTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "resolve", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "reject", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "snapshotter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "systemStatus", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "poolPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "autoscaleInterval", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "maybeRunInterval", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "queryingIsTaskReady", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "queryingIsFinished", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        (0, ow_1.default)(options, ow_1.default.object.exactShape({
+            runTaskFunction: ow_1.default.function,
+            isFinishedFunction: ow_1.default.function,
+            isTaskReadyFunction: ow_1.default.function,
+            maxConcurrency: ow_1.default.optional.number,
+            minConcurrency: ow_1.default.optional.number,
+            desiredConcurrency: ow_1.default.optional.number,
+            desiredConcurrencyRatio: ow_1.default.optional.number,
+            scaleUpStepRatio: ow_1.default.optional.number,
+            scaleDownStepRatio: ow_1.default.optional.number,
+            maybeRunIntervalSecs: ow_1.default.optional.number,
+            loggingIntervalSecs: ow_1.default.any(ow_1.default.number, ow_1.default.nullOrUndefined),
+            autoscaleIntervalSecs: ow_1.default.optional.number,
+            taskTimeoutSecs: ow_1.default.optional.number,
+            systemStatusOptions: ow_1.default.optional.object,
+            snapshotterOptions: ow_1.default.optional.object,
+            log: ow_1.default.optional.object,
+        }));
+        const { runTaskFunction, isFinishedFunction, isTaskReadyFunction, maxConcurrency = 1000, minConcurrency = 1, desiredConcurrency, desiredConcurrencyRatio = 0.90, scaleUpStepRatio = 0.05, scaleDownStepRatio = 0.05, maybeRunIntervalSecs = 0.5, loggingIntervalSecs = 60, taskTimeoutSecs = 0, autoscaleIntervalSecs = 10, systemStatusOptions, snapshotterOptions, log = log_1.log, } = options;
+        this.log = log.child({ prefix: 'AutoscaledPool' });
+        // Configurable properties.
+        this.desiredConcurrencyRatio = desiredConcurrencyRatio;
+        this.scaleUpStepRatio = scaleUpStepRatio;
+        this.scaleDownStepRatio = scaleDownStepRatio;
+        this.maybeRunIntervalMillis = maybeRunIntervalSecs * 1000;
+        this.loggingIntervalMillis = loggingIntervalSecs * 1000;
+        this.autoscaleIntervalMillis = autoscaleIntervalSecs * 1000;
+        this.taskTimeoutMillis = taskTimeoutSecs * 1000;
+        this.runTaskFunction = runTaskFunction;
+        this.isFinishedFunction = isFinishedFunction;
+        this.isTaskReadyFunction = isTaskReadyFunction;
+        // Internal properties.
+        this._minConcurrency = minConcurrency;
+        this._maxConcurrency = maxConcurrency;
+        this._desiredConcurrency = desiredConcurrency ?? minConcurrency;
+        this._currentConcurrency = 0;
+        this.isStopped = false;
+        this.lastLoggingTime = 0;
+        this.resolve = null;
+        this.reject = null;
+        this._autoscale = this._autoscale.bind(this);
+        this._maybeRunTask = this._maybeRunTask.bind(this);
+        // Create instances with correct options.
+        const ssoCopy = { ...systemStatusOptions };
+        ssoCopy.snapshotter ?? (ssoCopy.snapshotter = new snapshotter_1.Snapshotter({
+            ...snapshotterOptions,
+            log: this.log,
+            config: this.config,
+            client: this.config.getStorageClient(),
+        }));
+        ssoCopy.config ?? (ssoCopy.config = this.config);
+        this.snapshotter = ssoCopy.snapshotter;
+        this.systemStatus = new system_status_1.SystemStatus(ssoCopy);
+    }
+    /**
+     * Gets the minimum number of tasks running in parallel.
+     */
+    get minConcurrency() {
+        return this._minConcurrency;
+    }
+    /**
+     * Sets the minimum number of tasks running in parallel.
+     *
+     * *WARNING:* If you set this value too high with respect to the available system memory and CPU, your code might run extremely slow or crash.
+     * If you're not sure, just keep the default value and the concurrency will scale up automatically.
+     */
+    set minConcurrency(value) {
+        (0, ow_1.default)(value, ow_1.default.number);
+        this._minConcurrency = value;
+    }
+    /**
+     * Gets the maximum number of tasks running in parallel.
+     */
+    get maxConcurrency() {
+        return this._maxConcurrency;
+    }
+    /**
+     * Sets the maximum number of tasks running in parallel.
+     */
+    set maxConcurrency(value) {
+        (0, ow_1.default)(value, ow_1.default.number);
+        this._maxConcurrency = value;
+    }
+    /**
+     * Gets the desired concurrency for the pool,
+     * which is an estimated number of parallel tasks that the system can currently support.
+     */
+    get desiredConcurrency() {
+        return this._desiredConcurrency;
+    }
+    /**
+     * Sets the desired concurrency for the pool, i.e. the number of tasks that should be running
+     * in parallel if there's large enough supply of tasks.
+     */
+    set desiredConcurrency(value) {
+        (0, ow_1.default)(value, ow_1.default.number);
+        this._desiredConcurrency = value;
+    }
+    /**
+     * Gets the the number of parallel tasks currently running in the pool.
+     */
+    get currentConcurrency() {
+        return this._currentConcurrency;
+    }
+    /**
+     * Runs the auto-scaled pool. Returns a promise that gets resolved or rejected once
+     * all the tasks are finished or one of them fails.
+     */
+    async run() {
+        this.poolPromise = new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+        await this.snapshotter.start();
+        // This interval checks the system status and updates the desired concurrency accordingly.
+        this.autoscaleInterval = (0, utilities_1.betterSetInterval)(this._autoscale, this.autoscaleIntervalMillis);
+        // This is here because if we scale down to let's say 1, then after each promise is finished
+        // this._maybeRunTask() doesn't trigger another one. So if that 1 instance gets stuck it results
+        // in the actor getting stuck and even after scaling up it never triggers another promise.
+        this.maybeRunInterval = (0, utilities_1.betterSetInterval)(this._maybeRunTask, this.maybeRunIntervalMillis);
+        try {
+            await this.poolPromise;
+        }
+        finally {
+            // If resolve is null, the pool is already destroyed.
+            if (this.resolve)
+                await this._destroy();
+        }
+    }
+    /**
+     * Aborts the run of the auto-scaled pool and destroys it. The promise returned from
+     * the {@link AutoscaledPool.run} function will immediately resolve, no more new tasks
+     * will be spawned and all running tasks will be left in their current state.
+     *
+     * Due to the nature of the tasks, auto-scaled pool cannot reliably guarantee abortion
+     * of all the running tasks, therefore, no abortion is attempted and some of the tasks
+     * may finish, while others may not. Essentially, auto-scaled pool doesn't care about
+     * their state after the invocation of `.abort()`, but that does not mean that some
+     * parts of their asynchronous chains of commands will not execute.
+     */
+    async abort() {
+        this.isStopped = true;
+        if (this.resolve) {
+            this.resolve();
+            await this._destroy();
+        }
+    }
+    /**
+     * Prevents the auto-scaled pool from starting new tasks, but allows the running ones to finish
+     * (unlike abort, which terminates them). Used together with {@link AutoscaledPool.resume}
+     *
+     * The function's promise will resolve once all running tasks have completed and the pool
+     * is effectively idle. If the `timeoutSecs` argument is provided, the promise will reject
+     * with a timeout error after the `timeoutSecs` seconds.
+     *
+     * The promise returned from the {@link AutoscaledPool.run} function will not resolve
+     * when `.pause()` is invoked (unlike abort, which resolves it).
+     */
+    async pause(timeoutSecs) {
+        if (this.isStopped)
+            return;
+        this.isStopped = true;
+        return new Promise((resolve, reject) => {
+            let timeout;
+            if (timeoutSecs) {
+                timeout = setTimeout(() => {
+                    const err = new Error('The pool\'s running tasks did not finish'
+                        + `in ${timeoutSecs} secs after pool.pause() invocation.`);
+                    reject(err);
+                }, timeoutSecs);
+            }
+            const interval = setInterval(() => {
+                if (this._currentConcurrency <= 0) {
+                    // Clean up timeout and interval to prevent process hanging.
+                    if (timeout)
+                        clearTimeout(timeout);
+                    clearInterval(interval);
+                    resolve();
+                }
+            }, this.maybeRunIntervalMillis);
+        });
+    }
+    /**
+     * Resumes the operation of the autoscaled-pool by allowing more tasks to be run.
+     * Used together with {@link AutoscaledPool.pause}
+     *
+     * Tasks will automatically start running again in `options.maybeRunIntervalSecs`.
+     */
+    resume() {
+        this.isStopped = false;
+    }
+    /**
+     * Starts a new task
+     * if the number of running tasks (current concurrency) is lower than desired concurrency
+     * and the system is not currently overloaded
+     * and this.isTaskReadyFunction() returns true.
+     *
+     * It doesn't allow multiple concurrent runs of this method.
+     */
+    async _maybeRunTask(intervalCallback) {
+        this.log.perf('Attempting to run a task.');
+        // Check if the function was invoked by the maybeRunInterval and use an empty function if not.
+        const done = intervalCallback || (() => { });
+        // Prevent starting a new task if:
+        // - the pool is paused or aborted
+        if (this.isStopped) {
+            this.log.perf('Task will not run. AutoscaledPool is stopped.');
+            return done();
+        }
+        // - we are already querying for a task.
+        if (this.queryingIsTaskReady) {
+            this.log.perf('Task will not run. Waiting for a ready task.');
+            return done();
+        }
+        // - we would exceed desired concurrency.
+        if (this._currentConcurrency >= this._desiredConcurrency) {
+            this.log.perf('Task will not run. Desired concurrency achieved.');
+            return done();
+        }
+        // - system is overloaded now and we are at or above minConcurrency
+        const currentStatus = this.systemStatus.getCurrentStatus();
+        const { isSystemIdle } = currentStatus;
+        if (!isSystemIdle && this._currentConcurrency >= this._minConcurrency) {
+            this.log.perf('Task will not be run. System is overloaded.', currentStatus);
+            return done();
+        }
+        // - a task is ready.
+        this.queryingIsTaskReady = true;
+        let isTaskReady;
+        try {
+            this.log.perf('Checking for ready tasks.');
+            isTaskReady = await this.isTaskReadyFunction();
+        }
+        catch (e) {
+            const err = e;
+            this.log.perf('Checking for ready tasks failed.');
+            // We might have already rejected this promise.
+            if (this.reject) {
+                // No need to log all concurrent errors.
+                this.log.exception(err, 'isTaskReadyFunction failed');
+                this.reject(err);
+            }
+        }
+        finally {
+            this.queryingIsTaskReady = false;
+        }
+        if (!isTaskReady) {
+            this.log.perf('Task will not run. No tasks are ready.');
+            done();
+            // No tasks could mean that we're finished with all tasks.
+            return this._maybeFinish();
+        }
+        try {
+            // Everything's fine. Run task.
+            this._currentConcurrency++;
+            // Try to run next task to build up concurrency,
+            // but defer it so it doesn't create a cycle.
+            setImmediate(this._maybeRunTask);
+            // We need to restart interval here, so that it doesn't get blocked by a stalled task.
+            done();
+            // Execute the current task.
+            this.log.perf('Running a task.');
+            if (this.taskTimeoutMillis > 0) {
+                await (0, timeout_1.addTimeoutToPromise)(() => this.runTaskFunction(), this.taskTimeoutMillis, `runTaskFunction timed out after ${this.taskTimeoutMillis / 1000} seconds.`);
+            }
+            else {
+                await this.runTaskFunction();
+            }
+            this.log.perf('Task finished.');
+            this._currentConcurrency--;
+            // Run task after the previous one finished.
+            setImmediate(this._maybeRunTask);
+        }
+        catch (e) {
+            const err = e;
+            this.log.perf('Running a task failed.');
+            // We might have already rejected this promise.
+            if (this.reject) {
+                // No need to log all concurrent errors.
+                this.log.exception(err, 'runTaskFunction failed.');
+                this.reject(err);
+            }
+        }
+    }
+    /**
+     * Gets called every autoScaleIntervalSecs and evaluates the current system status.
+     * If the system IS NOT overloaded and the settings allow it, it scales up.
+     * If the system IS overloaded and the settings allow it, it scales down.
+     */
+    _autoscale(intervalCallback) {
+        // Don't scale if paused.
+        if (this.isStopped)
+            return intervalCallback();
+        // Only scale up if:
+        // - system has not been overloaded lately.
+        const systemStatus = this.systemStatus.getHistoricalStatus();
+        const { isSystemIdle } = systemStatus;
+        // - we're not already at max concurrency.
+        const weAreNotAtMax = this._desiredConcurrency < this._maxConcurrency;
+        // - current concurrency reaches at least the given ratio of desired concurrency.
+        const minCurrentConcurrency = Math.floor(this._desiredConcurrency * this.desiredConcurrencyRatio);
+        const weAreReachingDesiredConcurrency = this._currentConcurrency >= minCurrentConcurrency;
+        if (isSystemIdle && weAreNotAtMax && weAreReachingDesiredConcurrency)
+            this._scaleUp(systemStatus);
+        // Always scale down if:
+        // - the system has been overloaded lately.
+        const isSystemOverloaded = !isSystemIdle;
+        // - we're over min concurrency.
+        const weAreNotAtMin = this._desiredConcurrency > this._minConcurrency;
+        if (isSystemOverloaded && weAreNotAtMin)
+            this._scaleDown(systemStatus);
+        // On periodic intervals, print comprehensive log information
+        if (this.loggingIntervalMillis > 0) {
+            const now = Date.now();
+            if (now > this.lastLoggingTime + this.loggingIntervalMillis) {
+                this.lastLoggingTime = now;
+                this.log.info('state', {
+                    currentConcurrency: this._currentConcurrency,
+                    desiredConcurrency: this._desiredConcurrency,
+                    systemStatus,
+                });
+            }
+        }
+        // Start a new interval cycle.
+        intervalCallback();
+    }
+    /**
+     * Scales the pool up by increasing
+     * the desired concurrency by the scaleUpStepRatio.
+     *
+     * @param systemStatus for logging
+     */
+    _scaleUp(systemStatus) {
+        const step = Math.ceil(this._desiredConcurrency * this.scaleUpStepRatio);
+        this._desiredConcurrency = Math.min(this._maxConcurrency, this._desiredConcurrency + step);
+        this.log.debug('scaling up', {
+            oldConcurrency: this._desiredConcurrency - step,
+            newConcurrency: this._desiredConcurrency,
+            systemStatus,
+        });
+    }
+    /**
+     * Scales the pool down by decreasing
+     * the desired concurrency by the scaleDownStepRatio.
+     *
+     * @param systemStatus for logging
+     */
+    _scaleDown(systemStatus) {
+        const step = Math.ceil(this._desiredConcurrency * this.scaleDownStepRatio);
+        this._desiredConcurrency = Math.max(this._minConcurrency, this._desiredConcurrency - step);
+        this.log.debug('scaling down', {
+            oldConcurrency: this._desiredConcurrency + step,
+            newConcurrency: this._desiredConcurrency,
+            systemStatus,
+        });
+    }
+    /**
+     * If there are no running tasks and this.isFinishedFunction() returns true then closes
+     * the pool and resolves the pool's promise returned by the run() method.
+     *
+     * It doesn't allow multiple concurrent runs of this method.
+     */
+    async _maybeFinish() {
+        if (this.queryingIsFinished)
+            return;
+        if (this._currentConcurrency > 0)
+            return;
+        this.queryingIsFinished = true;
+        try {
+            const isFinished = await this.isFinishedFunction();
+            if (isFinished && this.resolve)
+                this.resolve();
+        }
+        catch (e) {
+            const err = e;
+            if (this.reject) {
+                // No need to log all concurrent errors.
+                this.log.exception(err, 'isFinishedFunction failed.');
+                this.reject(err);
+            }
+        }
+        finally {
+            this.queryingIsFinished = false;
+        }
+    }
+    /**
+     * Cleans up resources.
+     */
+    async _destroy() {
+        this.resolve = null;
+        this.reject = null;
+        (0, utilities_1.betterClearInterval)(this.autoscaleInterval);
+        (0, utilities_1.betterClearInterval)(this.maybeRunInterval);
+        if (this.snapshotter)
+            await this.snapshotter.stop();
+    }
+}
+exports.AutoscaledPool = AutoscaledPool;
+//# sourceMappingURL=autoscaled_pool.js.map

package/dist/autoscaling/autoscaled_pool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"autoscaled_pool.js","sourceRoot":"","sources":["../../src/autoscaling/autoscaled_pool.ts"],"names":[],"mappings":"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"}

package/dist/autoscaling/index.d.ts

@@ -0,0 +1,4 @@
+export * from './autoscaled_pool';
+export * from './snapshotter';
+export * from './system_status';
+//# sourceMappingURL=index.d.ts.map

package/dist/autoscaling/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/autoscaling/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC"}

package/dist/autoscaling/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./autoscaled_pool"), exports);
+tslib_1.__exportStar(require("./snapshotter"), exports);
+tslib_1.__exportStar(require("./system_status"), exports);
+//# sourceMappingURL=index.js.map

package/dist/autoscaling/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/autoscaling/index.ts"],"names":[],"mappings":";;;AAAA,4DAAkC;AAClC,wDAA8B;AAC9B,0DAAgC"}