@crawlee/core 4.0.0-beta.12 → 4.0.0-beta.121

package/autoscaling/system_status.js

@@ -1,52 +1,72 @@
-import { weightedAvg } from '@crawlee/utils';
-import ow from 'ow';
-import { Snapshotter } from './snapshotter.js';
+import { evaluateLoadSignalSample } from './load_signal.js';
 /**
- * Provides a simple interface to reading system status from a {@link Snapshotter} instance.
- * It only exposes two functions {@link SystemStatus.getCurrentStatus}
- * and {@link SystemStatus.getHistoricalStatus}.
- * The system status is calculated using a weighted average of overloaded
- * messages in the snapshots, with the weights being the time intervals
- * between the snapshots. Each resource is calculated separately
- * and the system is overloaded whenever at least one resource is overloaded.
- * The class is used by the {@link AutoscaledPool} class.
+ * How far back the *current* system status looks by default — the window that gates task dispatch.
+ * @internal
+ */
+export const DEFAULT_CURRENT_HISTORY_SECS = 5;
+/**
+ * How far back the *historical* system status looks by default — the window autoscaling decisions are based on, and
+ * therefore how much history the signals are asked to retain.
+ * @internal
+ */
+export const DEFAULT_SNAPSHOT_HISTORY_SECS = 30;
+/** The four built-in signal names that map to typed `SystemInfo` fields, and the option that switches each off. */
+const BUILTIN_SIGNAL_OPTION_KEYS = {
+    memInfo: 'memory',
+    eventLoopInfo: 'eventLoop',
+    cpuInfo: 'cpu',
+    clientInfo: 'client',
+};
+const BUILTIN_SIGNAL_NAMES = new Set(Object.keys(BUILTIN_SIGNAL_OPTION_KEYS));
+/**
+ * Reads the overload verdict of every signal — the {@link Snapshotter}'s built-in four plus any custom ones — and
+ * combines them into a {@link SystemInfo}: each signal is a time-weighted average of its snapshots, and the system
+ * is overloaded whenever at least one of them is.
  *
- * {@link SystemStatus.getCurrentStatus}
- * returns a boolean that represents the current status of the system.
- * The length of the current timeframe in seconds is configurable
- * by the `currentHistorySecs` option and represents the max age
- * of snapshots to be considered for the calculation.
+ * Evaluated over two windows, both requested explicitly from every signal so that a signal's private retention cannot
+ * widen what it contributes: a short `currentHistorySecs` one ({@link SystemStatus.getCurrentStatus}, gating task
+ * dispatch) and a longer `historySecs` one ({@link SystemStatus.getHistoricalStatus}, driving autoscaling).
  *
- * {@link SystemStatus.getHistoricalStatus}
- * returns a boolean that represents the long-term status
- * of the system. It considers the full snapshot history available
- * in the {@link Snapshotter} instance.
- * @category Scaling
+ * An implementation detail of the {@link ConcurrencySystem}, configured through
+ * {@link ConcurrencySystemOptions}.
+ * @internal
  */
 export class SystemStatus {
-    currentHistoryMillis;
-    maxMemoryOverloadedRatio;
-    maxEventLoopOverloadedRatio;
-    maxCpuOverloadedRatio;
-    maxClientOverloadedRatio;
-    snapshotter;
-    constructor(options = {}) {
-        ow(options, ow.object.exactShape({
-            currentHistorySecs: ow.optional.number,
-            maxMemoryOverloadedRatio: ow.optional.number,
-            maxEventLoopOverloadedRatio: ow.optional.number,
-            maxCpuOverloadedRatio: ow.optional.number,
-            maxClientOverloadedRatio: ow.optional.number,
-            snapshotter: ow.optional.object,
-            config: ow.optional.object,
-        }));
-        const { currentHistorySecs = 5, maxMemoryOverloadedRatio = 0.2, maxEventLoopOverloadedRatio = 0.6, maxCpuOverloadedRatio = 0.4, maxClientOverloadedRatio = 0.3, snapshotter, config, } = options;
-        this.currentHistoryMillis = currentHistorySecs * 1000;
-        this.maxMemoryOverloadedRatio = maxMemoryOverloadedRatio;
-        this.maxEventLoopOverloadedRatio = maxEventLoopOverloadedRatio;
-        this.maxCpuOverloadedRatio = maxCpuOverloadedRatio;
-        this.maxClientOverloadedRatio = maxClientOverloadedRatio;
-        this.snapshotter = snapshotter || new Snapshotter({ config });
+    #currentHistoryMillis;
+    #historyMillis;
+    #signals;
+    constructor(options) {
+        const { currentHistorySecs = DEFAULT_CURRENT_HISTORY_SECS, historySecs = DEFAULT_SNAPSHOT_HISTORY_SECS, snapshotter, loadSignals = [], } = options;
+        this.#currentHistoryMillis = currentHistorySecs * 1000;
+        this.#historyMillis = historySecs * 1000;
+        this.#signals = [...snapshotter.getLoadSignals(), ...loadSignals];
+        this.assertUniqueSignalNames();
+    }
+    /**
+     * The widest window any signal will be queried with, and therefore exactly how much history the signals are asked
+     * to retain when they start. Derived here, where the windows are resolved, so nothing has to reapply their
+     * defaults.
+     */
+    get maxSampleWindowMillis() {
+        return Math.max(this.#currentHistoryMillis, this.#historyMillis);
+    }
+    /**
+     * Signal names are the keys of the reported {@link SystemInfo}, so a duplicate would leave a status object that
+     * contradicts actual behavior: both signals are still evaluated (any overloaded one holds concurrency down), but
+     * only the last is reported.
+     */
+    assertUniqueSignalNames() {
+        const seen = new Set();
+        for (const { name } of this.#signals) {
+            if (!seen.has(name)) {
+                seen.add(name);
+                continue;
+            }
+            const hint = BUILTIN_SIGNAL_NAMES.has(name)
+                ? `it is the name of a built-in signal. To replace that signal, switch it off with \`loadSignals: { ${BUILTIN_SIGNAL_OPTION_KEYS[name]}: false }\` and keep your implementation in \`loadSignals.custom\`; to run yours alongside it, give it a different name.`
+                : 'two custom signals cannot share a name - rename one of them.';
+            throw new Error(`Duplicate load signal name ${JSON.stringify(name)}: ${hint}`);
+        }
     }
     /**
      * Returns an {@link SystemInfo} object with the following structure:
@@ -65,7 +85,7 @@ export class SystemStatus {
      * and `true` otherwise.
      */
     getCurrentStatus() {
-        return this._isSystemIdle(this.currentHistoryMillis);
+        return this.isSystemIdle(this.#currentHistoryMillis);
     }
     /**
      * Returns an {@link SystemInfo} object with the following structure:
@@ -79,91 +99,41 @@ export class SystemStatus {
      * }
      * ```
      *
-     * Where the `isSystemIdle` property is set to `false` if the system
-     * has been overloaded in the full history of the {@link Snapshotter}
-     * (which is configurable in the {@link Snapshotter}) and `true` otherwise.
+     * Where the `isSystemIdle` property is set to `false` if the system has been overloaded within the last
+     * `historySecs` seconds and `true` otherwise.
      */
     getHistoricalStatus() {
-        return this._isSystemIdle();
+        return this.isSystemIdle(this.#historyMillis);
     }
     /**
      * Returns a system status object.
      */
-    _isSystemIdle(sampleDurationMillis) {
-        const memInfo = this._isMemoryOverloaded(sampleDurationMillis);
-        const eventLoopInfo = this._isEventLoopOverloaded(sampleDurationMillis);
-        const cpuInfo = this._isCpuOverloaded(sampleDurationMillis);
-        const clientInfo = this._isClientOverloaded(sampleDurationMillis);
-        return {
-            isSystemIdle: !memInfo.isOverloaded &&
-                !eventLoopInfo.isOverloaded &&
-                !cpuInfo.isOverloaded &&
-                !clientInfo.isOverloaded,
-            memInfo,
-            eventLoopInfo,
-            cpuInfo,
-            clientInfo,
+    isSystemIdle(sampleDurationMillis) {
+        const result = {
+            isSystemIdle: true,
+            memInfo: { isOverloaded: false, limitRatio: 0, actualRatio: 0 },
+            eventLoopInfo: { isOverloaded: false, limitRatio: 0, actualRatio: 0 },
+            cpuInfo: { isOverloaded: false, limitRatio: 0, actualRatio: 0 },
+            clientInfo: { isOverloaded: false, limitRatio: 0, actualRatio: 0 },
         };
-    }
-    /**
-     * Returns an object with an isOverloaded property set to true
-     * if the memory has been overloaded in the last sampleDurationMillis.
-     */
-    _isMemoryOverloaded(sampleDurationMillis) {
-        const sample = this.snapshotter.getMemorySample(sampleDurationMillis);
-        return this._isSampleOverloaded(sample, this.maxMemoryOverloadedRatio);
-    }
-    /**
-     * Returns an object with an isOverloaded property set to true
-     * if the event loop has been overloaded in the last sampleDurationMillis.
-     */
-    _isEventLoopOverloaded(sampleDurationMillis) {
-        const sample = this.snapshotter.getEventLoopSample(sampleDurationMillis);
-        return this._isSampleOverloaded(sample, this.maxEventLoopOverloadedRatio);
-    }
-    /**
-     * Returns an object with an isOverloaded property set to true
-     * if the CPU has been overloaded in the last sampleDurationMillis.
-     */
-    _isCpuOverloaded(sampleDurationMillis) {
-        const sample = this.snapshotter.getCpuSample(sampleDurationMillis);
-        return this._isSampleOverloaded(sample, this.maxCpuOverloadedRatio);
-    }
-    /**
-     * Returns an object with an isOverloaded property set to true
-     * if the client has been overloaded in the last sampleDurationMillis.
-     */
-    _isClientOverloaded(sampleDurationMillis) {
-        const sample = this.snapshotter.getClientSample(sampleDurationMillis);
-        return this._isSampleOverloaded(sample, this.maxClientOverloadedRatio);
-    }
-    /**
-     * Returns an object with sample information and an isOverloaded property
-     * set to true if at least the ratio of snapshots in the sample are overloaded.
-     */
-    _isSampleOverloaded(sample, ratio) {
-        if (sample.length === 0) {
-            return {
-                isOverloaded: false,
-                limitRatio: ratio,
-                actualRatio: 0,
-            };
+        let loadSignalInfo;
+        for (const signal of this.#signals) {
+            const sample = signal.getSample(sampleDurationMillis);
+            const info = evaluateLoadSignalSample(sample, signal.overloadedRatio);
+            if (info.isOverloaded) {
+                result.isSystemIdle = false;
+            }
+            if (BUILTIN_SIGNAL_NAMES.has(signal.name)) {
+                result[signal.name] = info;
+            }
+            else {
+                loadSignalInfo ??= {};
+                loadSignalInfo[signal.name] = info;
+            }
         }
-        const weights = [];
-        const values = [];
-        for (let i = 1; i < sample.length; i++) {
-            const previous = sample[i - 1];
-            const current = sample[i];
-            const weight = +current.createdAt - +previous.createdAt;
-            weights.push(weight || 1); // Prevent errors from 0ms long intervals (sync) between snapshots.
-            values.push(+current.isOverloaded);
+        if (loadSignalInfo) {
+            result.loadSignalInfo = loadSignalInfo;
         }
-        const wAvg = sample.length === 1 ? +sample[0].isOverloaded : weightedAvg(values, weights);
-        return {
-            isOverloaded: wAvg > ratio,
-            limitRatio: ratio,
-            actualRatio: Math.round(wAvg * 1000) / 1000,
-        };
+        return result;
     }
 }
-//# sourceMappingURL=system_status.js.map

package/autoscaling/weighted_avg.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Computes a weighted average of an array of numbers, complemented by an array of weights.
+ * @ignore
+ */
+export declare function weightedAvg(arrValues: number[], arrWeights: number[]): number;

package/autoscaling/weighted_avg.js

@@ -0,0 +1,14 @@
+/**
+ * Computes a weighted average of an array of numbers, complemented by an array of weights.
+ * @ignore
+ */
+export function weightedAvg(arrValues, arrWeights) {
+    const result = arrValues
+        .map((value, i) => {
+        const weight = arrWeights[i];
+        const sum = value * weight;
+        return [sum, weight];
+    })
+        .reduce((p, c) => [p[0] + c[0], p[1] + c[1]], [0, 0]);
+    return result[0] / result[1];
+}

package/byte_utils.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Checks if the given value is a Node.js Stream or a Web API ReadableStream.
+ * @ignore
+ */
+export declare function isStream(value: unknown): value is NodeJS.ReadableStream | ReadableStream;
+/**
+ * Checks if the given value is a Node.js Buffer, ArrayBuffer, or TypedArray.
+ * @ignore
+ */
+export declare function isBuffer(value: unknown): value is Buffer | ArrayBuffer | ArrayBufferView;
+/**
+ * Converts a byte-like value (Buffer, ArrayBuffer, or any typed-array / DataView) into a Buffer over
+ * the exact same bytes, honoring `byteOffset` / `byteLength` for views. Existing Buffers are returned
+ * as-is. Used by storage backends, which persist raw bytes regardless of the input's concrete shape.
+ * @ignore
+ */
+export declare function toBuffer(value: Buffer | ArrayBuffer | ArrayBufferView): Buffer;

package/byte_utils.js

@@ -0,0 +1,42 @@
+/**
+ * Checks if the given value is a Node.js Stream or a Web API ReadableStream.
+ * @ignore
+ */
+export function isStream(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    // A Node.js Readable is both pipeable and async-iterable; a Web ReadableStream exposes pipeTo.
+    // Requiring async-iterability for the `pipe` branch rejects plain `{ pipe }` ducks that would
+    // otherwise blow up later in the storage backends' drain loop with a cryptic TypeError.
+    const isNodeStream = typeof value.pipe === 'function' && typeof value[Symbol.asyncIterator] === 'function';
+    const isWebStream = typeof value.pipeTo === 'function';
+    return isNodeStream || isWebStream;
+}
+/**
+ * Checks if the given value is a Node.js Buffer, ArrayBuffer, or TypedArray.
+ * @ignore
+ */
+export function isBuffer(value) {
+    return (value != null &&
+        typeof value === 'object' &&
+        (Buffer.isBuffer(value) ||
+            value instanceof ArrayBuffer ||
+            ArrayBuffer.isView(value) ||
+            value.constructor?.name === 'Buffer'));
+}
+/**
+ * Converts a byte-like value (Buffer, ArrayBuffer, or any typed-array / DataView) into a Buffer over
+ * the exact same bytes, honoring `byteOffset` / `byteLength` for views. Existing Buffers are returned
+ * as-is. Used by storage backends, which persist raw bytes regardless of the input's concrete shape.
+ * @ignore
+ */
+export function toBuffer(value) {
+    if (Buffer.isBuffer(value)) {
+        return value;
+    }
+    if (value instanceof ArrayBuffer) {
+        return Buffer.from(value);
+    }
+    return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+}