@crawlee/core 4.0.0-beta.87 → 4.0.0-beta.89

package/autoscaling/memory_load_signal.js

@@ -5,36 +5,45 @@ import { SnapshotStore } from './load_signal.js';
 const RESERVE_MEMORY_RATIO = 0.5;
 const CRITICAL_OVERLOAD_RATE_LIMIT_MILLIS = 10_000;
 /**
- * Tracks memory usage via `SYSTEM_INFO` events and reports overload when
- * the used-to-available memory ratio exceeds a threshold.
+ * Tracks memory usage via `SYSTEM_INFO` events and reports overload when the used-to-available memory ratio exceeds a
+ * threshold. Also warns when memory use becomes critical.
+ *
+ * Built by default; construct one yourself only to wrap or adapt it — see {@link LoadSignal}.
+ *
+ * @category Scaling
  */
 export class MemoryLoadSignal {
     name = 'memInfo';
     overloadedRatio;
-    store;
-    configuration;
-    events;
+    store = new SnapshotStore();
+    maxUsedRatio;
+    /** All resolved in `start()`, before anything that reads them can fire. */
+    config;
     log;
-    maxUsedMemoryRatio;
-    maxMemoryRatio;
     maxMemoryBytes;
+    events;
+    maxMemoryRatio;
     lastLoggedCriticalMemoryOverloadAt = null;
-    constructor(options) {
-        this.store = new SnapshotStore(options.snapshotHistoryMillis);
-        this.configuration = options.configuration;
-        this.events = serviceLocator.getEventManager();
-        this.log = options.log ?? serviceLocator.getLogger().child({ prefix: 'MemoryLoadSignal' });
-        this.maxUsedMemoryRatio = options.maxUsedMemoryRatio ?? 0.9;
+    constructor(options = {}) {
+        this.maxUsedRatio = options.maxUsedRatio ?? 0.9;
         this.overloadedRatio = options.overloadedRatio ?? 0.2;
-        this._onSystemInfo = this._onSystemInfo.bind(this);
+        this.handle = this.handle.bind(this);
     }
-    async start() {
-        const memoryMbytes = this.configuration.memoryMbytes ?? 0;
+    async start(context) {
+        this.store.useSampleWindow(context.maxSampleWindowMillis);
+        // A new session starts from a clean slate, so it is not judged on measurements from before the downtime.
+        this.store.clear();
+        // Resolved here rather than in the constructor: an instance built ahead of time (to be wrapped, or shared
+        // between systems) must not capture whichever services happened to be registered at that moment.
+        this.config = serviceLocator.getConfiguration();
+        this.events = serviceLocator.getEventManager();
+        this.log = serviceLocator.getLogger().child({ prefix: 'MemoryLoadSignal' });
+        const memoryMbytes = this.config.memoryMbytes ?? 0;
         if (memoryMbytes > 0) {
             this.maxMemoryBytes = memoryMbytes * 1024 * 1024;
         }
         else {
-            this.maxMemoryRatio = this.configuration.availableMemoryRatio;
+            this.maxMemoryRatio = this.config.availableMemoryRatio;
             if (!this.maxMemoryRatio) {
                 throw new Error('availableMemoryRatio is not set in configuration.');
             }
@@ -45,22 +54,17 @@ export class MemoryLoadSignal {
             // Fallback memory measurement in case memTotalBytes is missing from SystemInfo.
             this.maxMemoryBytes = await this._getTotalMemoryBytes();
         }
-        this.events.on("systemInfo" /* EventType.SYSTEM_INFO */, this._onSystemInfo);
+        this.events.on("systemInfo" /* EventType.SYSTEM_INFO */, this.handle);
     }
     async stop() {
-        this.events.off("systemInfo" /* EventType.SYSTEM_INFO */, this._onSystemInfo);
+        this.events?.off("systemInfo" /* EventType.SYSTEM_INFO */, this.handle);
+        this.events = undefined;
     }
     getSample(sampleDurationMillis) {
         return this.store.getSample(sampleDurationMillis);
     }
-    /**
-     * Returns typed memory snapshots for backward compatibility with `Snapshotter`.
-     */
-    getMemorySnapshots() {
-        return this.store.getAll();
-    }
-    /** @internal */
-    _onSystemInfo(systemInfo) {
+    /** @internal Records a snapshot from a `SYSTEM_INFO` payload. Exposed for tests. */
+    handle(systemInfo) {
         const createdAt = systemInfo.createdAt ? new Date(systemInfo.createdAt) : new Date();
         const { memCurrentBytes, memTotalBytes } = systemInfo;
         let maxMemoryBytes = this.maxMemoryBytes;
@@ -69,7 +73,7 @@ export class MemoryLoadSignal {
         }
         const snapshot = {
             createdAt,
-            isOverloaded: memCurrentBytes / maxMemoryBytes > this.maxUsedMemoryRatio,
+            isOverloaded: memCurrentBytes / maxMemoryBytes > this.maxUsedRatio,
             usedBytes: memCurrentBytes,
         };
         this.store.push(snapshot, createdAt);
@@ -83,8 +87,8 @@ export class MemoryLoadSignal {
         if (this.lastLoggedCriticalMemoryOverloadAt &&
             +createdAt < +this.lastLoggedCriticalMemoryOverloadAt + CRITICAL_OVERLOAD_RATE_LIMIT_MILLIS)
             return;
-        const maxDesiredMemoryBytes = this.maxUsedMemoryRatio * effectiveMax;
-        const reserveMemory = effectiveMax * (1 - this.maxUsedMemoryRatio) * RESERVE_MEMORY_RATIO;
+        const maxDesiredMemoryBytes = this.maxUsedRatio * effectiveMax;
+        const reserveMemory = effectiveMax * (1 - this.maxUsedRatio) * RESERVE_MEMORY_RATIO;
         const criticalOverloadBytes = maxDesiredMemoryBytes + reserveMemory;
         const isCriticalOverload = memCurrentBytes > criticalOverloadBytes;
         if (isCriticalOverload) {
@@ -96,7 +100,7 @@ export class MemoryLoadSignal {
         }
     }
     async _getTotalMemoryBytes() {
-        const containerized = this.configuration.containerized ?? (await isContainerized());
+        const containerized = this.config.containerized ?? (await isContainerized());
         return (await getMemoryInfo({ containerized, logger: serviceLocator.getLogger() })).totalBytes;
     }
 }

package/autoscaling/snapshotter.d.ts

@@ -1,127 +1,87 @@
-import type { StorageBackend } from '@crawlee/types';
-import type { Configuration } from '../configuration.js';
-import type { CrawleeLogger } from '../log.js';
-import type { ClientSnapshot } from './client_load_signal.js';
-import type { CpuSnapshot } from './cpu_load_signal.js';
-import type { EventLoopSnapshot } from './event_loop_load_signal.js';
-import type { LoadSignal } from './load_signal.js';
-import type { MemorySnapshot } from './memory_load_signal.js';
-export interface SnapshotterOptions {
-    /**
-     * Defines the interval of measuring the event loop response time.
-     * @default 0.5
-     */
-    eventLoopSnapshotIntervalSecs?: number;
+import type { ClientLoadSignalOptions } from './client_load_signal.js';
+import type { CpuLoadSignalOptions } from './cpu_load_signal.js';
+import type { EventLoopLoadSignalOptions } from './event_loop_load_signal.js';
+import type { LoadSignal, LoadSignalStartContext } from './load_signal.js';
+import type { MemoryLoadSignalOptions } from './memory_load_signal.js';
+/**
+ * The load signals a {@link ConcurrencySystem} watches to decide whether the machine is overloaded.
+ *
+ * Each of the four built-in signals is configured by passing its options bag — shorthand for constructing the
+ * corresponding {@link LoadSignal} class yourself, so `{ cpu: { overloadedRatio: 0.5 } }` is exactly
+ * `{ cpu: false, custom: [new CpuLoadSignal({ overloadedRatio: 0.5 })] }`. Pass `false` to leave a resource
+ * unwatched, and put anything else you want taken into account in {@link LoadSignalsOptions.custom|`custom`}.
+ *
+ * How far back the signals are evaluated is *not* set here, but by
+ * {@link ConcurrencySystemOptions.snapshotHistorySecs|`snapshotHistorySecs`} and
+ * {@link ConcurrencySystemOptions.currentHistorySecs|`currentHistorySecs`}.
+ */
+export interface LoadSignalsOptions {
     /**
-     * Defines the interval of checking the current state
-     * of the remote API client.
-     * @default 1
+     * Tuning for the built-in {@link MemoryLoadSignal} (used-memory limit + overload ratio), or `false` to switch
+     * it off.
      */
-    clientSnapshotIntervalSecs?: number;
+    memory?: MemoryLoadSignalOptions | false;
     /**
-     * Maximum allowed delay of the event loop in milliseconds.
-     * Exceeding this limit overloads the event loop.
-     * @default 50
+     * Tuning for the built-in {@link EventLoopLoadSignal} (snapshot interval + blocked-millis limit + overload
+     * ratio), or `false` to switch it off — which also stops its measuring interval.
      */
-    maxBlockedMillis?: number;
+    eventLoop?: EventLoopLoadSignalOptions | false;
     /**
-     * Defines the maximum ratio of total memory that can be used.
-     * Exceeding this limit overloads the memory.
-     * @default 0.9
+     * Tuning for the built-in {@link CpuLoadSignal} (overload ratio), or `false` to switch it off.
      */
-    maxUsedMemoryRatio?: number;
+    cpu?: CpuLoadSignalOptions | false;
     /**
-     * Defines the maximum number of new rate limit errors within
-     * the given interval.
-     * @default 3
+     * Tuning for the built-in {@link ClientLoadSignal} (snapshot interval + error limit + overload ratio), or
+     * `false` to switch it off — worth doing when the storage backend reports no rate-limit statistics, since the
+     * signal otherwise polls it every second to no purpose.
      */
-    maxClientErrors?: number;
+    client?: ClientLoadSignalOptions | false;
     /**
-     * Sets the interval in seconds for which a history of resource snapshots
-     * will be kept. Increasing this to very high numbers will affect performance.
-     * @default 30
+     * Additional {@link LoadSignal} implementations — e.g. navigation timeouts or proxy health — evaluated
+     * alongside the built-in four. If any signal reports overload, the system counts as overloaded. Their lifecycle
+     * is driven by the {@link ConcurrencySystem} they are given to, and their {@link LoadSignal.name|names} must
+     * not collide with an enabled built-in's.
      */
-    snapshotHistorySecs?: number;
-    /** @internal */
-    log?: CrawleeLogger;
-    /** @internal */
-    client?: StorageBackend;
-    /** @internal */
-    configuration?: Configuration;
+    custom?: LoadSignal[];
 }
 /**
- * Creates snapshots of system resources at given intervals and marks the resource
- * as either overloaded or not during the last interval. Keeps a history of the snapshots.
- * It tracks the following resources: Memory, EventLoop, API and CPU.
- * The class is used by the {@link AutoscaledPool} class.
- *
- * When running on the Apify platform, the CPU and memory statistics are provided by the platform,
- * as collected from the running Docker container. When running locally, `Snapshotter`
- * makes its own statistics by querying the OS.
- *
- * CPU becomes overloaded locally when its current use exceeds the `maxUsedCpuRatio` option or
- * when Apify platform marks it as overloaded.
- *
- * Memory becomes overloaded if its current use exceeds the `maxUsedMemoryRatio` option.
- * It's computed using the total memory available to the container when running on
- * the Apify platform and a quarter of total system memory when running locally.
- * Max total memory when running locally may be overridden by using the `CRAWLEE_MEMORY_MBYTES`
- * environment variable.
- *
- * Event loop becomes overloaded if it slows down by more than the `maxBlockedMillis` option.
- *
- * Client becomes overloaded when rate limit errors (429 - Too Many Requests),
- * typically received from the request queue, exceed the set limit within the set interval.
+ * An implementation detail of the {@link ConcurrencySystem}: the built-in signal tuning from
+ * {@link LoadSignalsOptions}, minus the custom signals, which the system evaluates itself rather than collecting
+ * them here.
+ * @internal
+ */
+export type SnapshotterOptions = Omit<LoadSignalsOptions, 'custom'>;
+/**
+ * Owns the four built-in {@link LoadSignal} instances — {@link MemoryLoadSignal},
+ * {@link EventLoopLoadSignal}, {@link CpuLoadSignal} and {@link ClientLoadSignal} — constructing the ones
+ * that were not switched off and driving their shared lifecycle.
  *
- * @category Scaling
+ * Configured indirectly through {@link ConcurrencySystemOptions.loadSignals|`loadSignals`}, whose per-signal bags
+ * are simply forwarded to the corresponding constructor.
+ * @internal
  */
 export declare class Snapshotter {
-    readonly log: CrawleeLogger;
-    readonly client: StorageBackend;
-    readonly configuration: Configuration;
-    private readonly memorySignal;
-    private readonly eventLoopSignal;
-    private readonly cpuSignal;
-    private readonly clientSignal;
+    private readonly memorySignal?;
+    private readonly eventLoopSignal?;
+    private readonly cpuSignal?;
+    private readonly clientSignal?;
     /**
-     * Returns the four built-in signals as an array, so `SystemStatus` can
-     * iterate them alongside any custom `LoadSignal` instances.
+     * Returns the enabled built-in signals, so `SystemStatus` can iterate them alongside any custom `LoadSignal`
+     * instances. Signals switched off through the options are simply absent — the system status reports them as
+     * not overloaded.
      */
     getLoadSignals(): LoadSignal[];
-    get cpuSnapshots(): CpuSnapshot[];
-    get eventLoopSnapshots(): EventLoopSnapshot[];
-    get memorySnapshots(): MemorySnapshot[];
-    get clientSnapshots(): ClientSnapshot[];
     /**
      * @param [options] All `Snapshotter` configuration options.
      */
     constructor(options?: SnapshotterOptions);
     /**
-     * Starts capturing snapshots at configured intervals.
+     * Starts capturing snapshots at configured intervals. The `context` carries the sample window the signals will
+     * be queried with, which is also how much history they retain.
      */
-    start(): Promise<void>;
+    start(context: LoadSignalStartContext): Promise<void>;
     /**
      * Stops all resource capturing.
      */
     stop(): Promise<void>;
-    /**
-     * Returns a sample of latest memory snapshots, with the size of the sample defined
-     * by the sampleDurationMillis parameter. If omitted, it returns a full snapshot history.
-     */
-    getMemorySample(sampleDurationMillis?: number): MemorySnapshot[];
-    /**
-     * Returns a sample of latest event loop snapshots, with the size of the sample defined
-     * by the sampleDurationMillis parameter. If omitted, it returns a full snapshot history.
-     */
-    getEventLoopSample(sampleDurationMillis?: number): EventLoopSnapshot[];
-    /**
-     * Returns a sample of latest CPU snapshots, with the size of the sample defined
-     * by the sampleDurationMillis parameter. If omitted, it returns a full snapshot history.
-     */
-    getCpuSample(sampleDurationMillis?: number): CpuSnapshot[];
-    /**
-     * Returns a sample of latest Client snapshots, with the size of the sample defined
-     * by the sampleDurationMillis parameter. If omitted, it returns a full snapshot history.
-     */
-    getClientSample(sampleDurationMillis?: number): ClientSnapshot[];
 }

package/autoscaling/snapshotter.js

@@ -1,153 +1,67 @@
-import ow from 'ow';
-import { serviceLocator } from '../service_locator.js';
-import { createClientLoadSignal } from './client_load_signal.js';
-import { createCpuLoadSignal } from './cpu_load_signal.js';
-import { createEventLoopLoadSignal } from './event_loop_load_signal.js';
+import { ClientLoadSignal } from './client_load_signal.js';
+import { CpuLoadSignal } from './cpu_load_signal.js';
+import { EventLoopLoadSignal } from './event_loop_load_signal.js';
 import { MemoryLoadSignal } from './memory_load_signal.js';
 /**
- * Creates snapshots of system resources at given intervals and marks the resource
- * as either overloaded or not during the last interval. Keeps a history of the snapshots.
- * It tracks the following resources: Memory, EventLoop, API and CPU.
- * The class is used by the {@link AutoscaledPool} class.
+ * Owns the four built-in {@link LoadSignal} instances — {@link MemoryLoadSignal},
+ * {@link EventLoopLoadSignal}, {@link CpuLoadSignal} and {@link ClientLoadSignal} — constructing the ones
+ * that were not switched off and driving their shared lifecycle.
  *
- * When running on the Apify platform, the CPU and memory statistics are provided by the platform,
- * as collected from the running Docker container. When running locally, `Snapshotter`
- * makes its own statistics by querying the OS.
- *
- * CPU becomes overloaded locally when its current use exceeds the `maxUsedCpuRatio` option or
- * when Apify platform marks it as overloaded.
- *
- * Memory becomes overloaded if its current use exceeds the `maxUsedMemoryRatio` option.
- * It's computed using the total memory available to the container when running on
- * the Apify platform and a quarter of total system memory when running locally.
- * Max total memory when running locally may be overridden by using the `CRAWLEE_MEMORY_MBYTES`
- * environment variable.
- *
- * Event loop becomes overloaded if it slows down by more than the `maxBlockedMillis` option.
- *
- * Client becomes overloaded when rate limit errors (429 - Too Many Requests),
- * typically received from the request queue, exceed the set limit within the set interval.
- *
- * @category Scaling
+ * Configured indirectly through {@link ConcurrencySystemOptions.loadSignals|`loadSignals`}, whose per-signal bags
+ * are simply forwarded to the corresponding constructor.
+ * @internal
  */
 export class Snapshotter {
-    log;
-    client;
-    configuration;
+    // Absent when switched off through the corresponding option (e.g. `client: false`).
     memorySignal;
     eventLoopSignal;
     cpuSignal;
     clientSignal;
     /**
-     * Returns the four built-in signals as an array, so `SystemStatus` can
-     * iterate them alongside any custom `LoadSignal` instances.
+     * Returns the enabled built-in signals, so `SystemStatus` can iterate them alongside any custom `LoadSignal`
+     * instances. Signals switched off through the options are simply absent — the system status reports them as
+     * not overloaded.
      */
     getLoadSignals() {
-        return [this.memorySignal, this.eventLoopSignal, this.cpuSignal, this.clientSignal];
-    }
-    // Legacy public properties kept for backward compat (tests read these directly)
-    get cpuSnapshots() {
-        return this.cpuSignal.store.getAll();
-    }
-    get eventLoopSnapshots() {
-        return this.eventLoopSignal.store.getAll();
-    }
-    get memorySnapshots() {
-        return this.memorySignal.getMemorySnapshots();
-    }
-    get clientSnapshots() {
-        return this.clientSignal.store.getAll();
+        const builtin = [
+            this.memorySignal,
+            this.eventLoopSignal,
+            this.cpuSignal,
+            this.clientSignal,
+        ];
+        return builtin.filter((signal) => signal !== undefined);
     }
     /**
      * @param [options] All `Snapshotter` configuration options.
      */
     constructor(options = {}) {
-        ow(options, ow.object.exactShape({
-            eventLoopSnapshotIntervalSecs: ow.optional.number,
-            clientSnapshotIntervalSecs: ow.optional.number,
-            snapshotHistorySecs: ow.optional.number,
-            maxBlockedMillis: ow.optional.number,
-            maxUsedMemoryRatio: ow.optional.number,
-            maxClientErrors: ow.optional.number,
-            log: ow.optional.object,
-            client: ow.optional.object,
-            configuration: ow.optional.object,
-        }));
-        const { eventLoopSnapshotIntervalSecs = 0.5, clientSnapshotIntervalSecs = 1, snapshotHistorySecs = 30, maxBlockedMillis = 50, maxUsedMemoryRatio = 0.9, maxClientErrors = 3, log = serviceLocator.getLogger(), configuration = serviceLocator.getConfiguration(), client = serviceLocator.getStorageBackend(), } = options;
-        this.log = log.child({ prefix: 'Snapshotter' });
-        this.client = client;
-        this.configuration = configuration;
-        const snapshotHistoryMillis = snapshotHistorySecs * 1000;
-        this.memorySignal = new MemoryLoadSignal({
-            maxUsedMemoryRatio,
-            snapshotHistoryMillis,
-            configuration: this.configuration,
-            log: this.log,
-        });
-        this.eventLoopSignal = createEventLoopLoadSignal({
-            eventLoopSnapshotIntervalSecs,
-            maxBlockedMillis,
-            snapshotHistoryMillis,
-        });
-        this.cpuSignal = createCpuLoadSignal({
-            snapshotHistoryMillis,
-            configuration: this.configuration,
-        });
-        this.clientSignal = createClientLoadSignal({
-            client: this.client,
-            clientSnapshotIntervalSecs,
-            maxClientErrors,
-            snapshotHistoryMillis,
-        });
+        const { memory = {}, eventLoop = {}, cpu = {}, client = {} } = options;
+        // Each signal resolves its own ambient dependencies when started, and is told the window it will be sampled
+        // over then too - so there is nothing to thread in here beyond the caller's tuning.
+        if (memory !== false)
+            this.memorySignal = new MemoryLoadSignal(memory);
+        if (eventLoop !== false)
+            this.eventLoopSignal = new EventLoopLoadSignal(eventLoop);
+        if (cpu !== false)
+            this.cpuSignal = new CpuLoadSignal(cpu);
+        if (client !== false)
+            this.clientSignal = new ClientLoadSignal(client);
     }
     /**
-     * Starts capturing snapshots at configured intervals.
+     * Starts capturing snapshots at configured intervals. The `context` carries the sample window the signals will
+     * be queried with, which is also how much history they retain.
      */
-    async start() {
-        await this.memorySignal.start();
-        await this.eventLoopSignal.start();
-        await this.cpuSignal.start();
-        await this.clientSignal.start();
+    async start(context) {
+        await Promise.all(this.getLoadSignals().map(async (signal) => signal.start(context)));
     }
     /**
      * Stops all resource capturing.
      */
     async stop() {
-        await this.memorySignal.stop();
-        await this.eventLoopSignal.stop();
-        await this.cpuSignal.stop();
-        await this.clientSignal.stop();
+        await Promise.all(this.getLoadSignals().map(async (signal) => signal.stop()));
         // Allow microtask queue to unwind before stop returns.
         await new Promise((resolve) => {
             setImmediate(resolve);
         });
     }
-    /**
-     * Returns a sample of latest memory snapshots, with the size of the sample defined
-     * by the sampleDurationMillis parameter. If omitted, it returns a full snapshot history.
-     */
-    getMemorySample(sampleDurationMillis) {
-        return this.memorySignal.getSample(sampleDurationMillis);
-    }
-    /**
-     * Returns a sample of latest event loop snapshots, with the size of the sample defined
-     * by the sampleDurationMillis parameter. If omitted, it returns a full snapshot history.
-     */
-    getEventLoopSample(sampleDurationMillis) {
-        return this.eventLoopSignal.getSample(sampleDurationMillis);
-    }
-    /**
-     * Returns a sample of latest CPU snapshots, with the size of the sample defined
-     * by the sampleDurationMillis parameter. If omitted, it returns a full snapshot history.
-     */
-    getCpuSample(sampleDurationMillis) {
-        return this.cpuSignal.getSample(sampleDurationMillis);
-    }
-    /**
-     * Returns a sample of latest Client snapshots, with the size of the sample defined
-     * by the sampleDurationMillis parameter. If omitted, it returns a full snapshot history.
-     */
-    getClientSample(sampleDurationMillis) {
-        return this.clientSignal.getSample(sampleDurationMillis);
-    }
 }

package/autoscaling/system_status.d.ts

@@ -1,5 +1,5 @@
 import type { LoadSignal } from './load_signal.js';
-import { Snapshotter } from './snapshotter.js';
+import type { Snapshotter } from './snapshotter.js';
 /**
  * Represents the current status of the system.
  */
@@ -33,6 +33,22 @@ export interface SystemInfo {
      */
     loadSignalInfo?: Record<string, ClientInfo>;
 }
+/**
+ * How far back the *current* system status looks by default — the window that gates task dispatch.
+ * @internal
+ */
+export declare 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 declare const DEFAULT_SNAPSHOT_HISTORY_SECS = 30;
+/**
+ * An implementation detail of the {@link ConcurrencySystem} — configure it through
+ * {@link ConcurrencySystemOptions} (`loadSignals`, `currentHistorySecs` and `snapshotHistorySecs`).
+ * @internal
+ */
 export interface SystemStatusOptions {
     /**
      * Defines max age of snapshots used in the {@link SystemStatus.getCurrentStatus} measurement.
@@ -40,38 +56,21 @@ export interface SystemStatusOptions {
      */
     currentHistorySecs?: number;
     /**
-     * Sets the maximum ratio of overloaded snapshots in a memory sample.
-     * If the sample exceeds this ratio, the system will be overloaded.
-     * @default 0.2
-     */
-    maxMemoryOverloadedRatio?: number;
-    /**
-     * Sets the maximum ratio of overloaded snapshots in an event loop sample.
-     * If the sample exceeds this ratio, the system will be overloaded.
-     * @default 0.6
+     * Defines max age of snapshots used in the {@link SystemStatus.getHistoricalStatus} measurement — the window
+     * autoscaling decisions are based on. Applied uniformly to every signal, built-in or custom, so that a signal's
+     * private retention cannot silently widen the window.
+     * @default 30
      */
-    maxEventLoopOverloadedRatio?: number;
+    historySecs?: number;
     /**
-     * Sets the maximum ratio of overloaded snapshots in a CPU sample.
-     * If the sample exceeds this ratio, the system will be overloaded.
-     * @default 0.4
+     * The `Snapshotter` whose built-in signals are evaluated.
      */
-    maxCpuOverloadedRatio?: number;
-    /**
-     * Sets the maximum ratio of overloaded snapshots in a Client sample.
-     * If the sample exceeds this ratio, the system will be overloaded.
-     * @default 0.3
-     */
-    maxClientOverloadedRatio?: number;
-    /**
-     * The `Snapshotter` instance to be queried for `SystemStatus`.
-     */
-    snapshotter?: Snapshotter;
+    snapshotter: Snapshotter;
     /**
      * Additional load signals to include in the system status evaluation.
      * These are evaluated alongside the built-in memory, CPU, event loop,
      * and client signals. If any signal reports overload, the system is
-     * considered overloaded.
+     * considered overloaded. Each signal carries its own overload ratio.
      */
     loadSignals?: LoadSignal[];
 }
@@ -93,38 +92,35 @@ export interface FinalStatistics {
     crawlerRuntimeMillis: number;
 }
 /**
- * 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.
+ * 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 declare class SystemStatus {
     private readonly currentHistoryMillis;
-    private readonly snapshotter;
+    private readonly historyMillis;
     private readonly signals;
+    constructor(options: SystemStatusOptions);
     /**
-     * Per-signal ratio overrides. The built-in four get their overrides from
-     * the legacy `max*OverloadedRatio` options; custom signals use their own
-     * `overloadedRatio`.
+     * 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.
      */
-    private ratioOverrides;
-    constructor(options?: SystemStatusOptions);
+    get maxSampleWindowMillis(): number;
+    /**
+     * 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.
+     */
+    private assertUniqueSignalNames;
     /**
      * Returns an {@link SystemInfo} object with the following structure:
      *
@@ -154,9 +150,8 @@ export declare 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(): SystemInfo;
     /**