@crawlee/core 4.0.0-beta.98 → 4.0.0-rc.0

package/autoscaling/load_signal.js

@@ -4,8 +4,9 @@ import { weightedAvg } from './weighted_avg.js';
  * and so can yours — it is the only part of their machinery worth reusing.
  */
 export class SnapshotStore {
-    snapshots = [];
+    #snapshots = [];
     /** Retention window in milliseconds. Unbounded until {@link SnapshotStore.useSampleWindow|`useSampleWindow()`}. */
+    // kept as TS-private: concurrency_system tests read this retention window directly
     historyMillis = Infinity;
     /**
      * Sizes retention to the window the signal will be sampled over, as handed to it in
@@ -21,30 +22,30 @@ export class SnapshotStore {
     push(snapshot, now = snapshot.createdAt) {
         // Inline pruning to avoid private-method transpilation issues
         let oldCount = 0;
-        for (let i = 0; i < this.snapshots.length; i++) {
-            const { createdAt } = this.snapshots[i];
+        for (let i = 0; i < this.#snapshots.length; i++) {
+            const { createdAt } = this.#snapshots[i];
             if (now.getTime() - new Date(createdAt).getTime() > this.historyMillis)
                 oldCount++;
             else
                 break;
         }
         if (oldCount)
-            this.snapshots.splice(0, oldCount);
-        this.snapshots.push(snapshot);
+            this.#snapshots.splice(0, oldCount);
+        this.#snapshots.push(snapshot);
     }
     /**
      * Return all snapshots, or only those within the given time window.
      */
     getSample(sampleDurationMillis) {
         if (!sampleDurationMillis)
-            return this.snapshots;
+            return this.#snapshots;
         const sample = [];
-        let idx = this.snapshots.length;
+        let idx = this.#snapshots.length;
         if (!idx)
             return sample;
-        const latestTime = this.snapshots[idx - 1].createdAt;
+        const latestTime = this.#snapshots[idx - 1].createdAt;
         while (idx--) {
-            const snapshot = this.snapshots[idx];
+            const snapshot = this.#snapshots[idx];
             if (+latestTime - +snapshot.createdAt <= sampleDurationMillis) {
                 sample.unshift(snapshot);
             }
@@ -56,10 +57,11 @@ export class SnapshotStore {
     }
     /**
      * Direct, unwindowed access to the underlying array — used by signals whose handler needs the previous snapshot
-     * to compute a delta (e.g. the event loop and client signals read the last entry to measure change since it).
+     * to compute a delta (e.g. the event loop and storage backend signals read the last entry to measure change since
+     * it).
      */
     getAll() {
-        return this.snapshots;
+        return this.#snapshots;
     }
     /**
      * Discards every retained snapshot. The built-in signals do this when they *start*, so that a session neither
@@ -68,7 +70,7 @@ export class SnapshotStore {
      * rather than on stop leaves a finished session readable.
      */
     clear() {
-        this.snapshots = [];
+        this.#snapshots = [];
     }
 }
 /**

package/autoscaling/memory_load_signal.d.ts

@@ -33,24 +33,15 @@ export interface MemoryLoadSignalOptions {
  * @category Scaling
  */
 export declare class MemoryLoadSignal implements LoadSignal {
+    #private;
     readonly name = "memInfo";
     readonly overloadedRatio: number;
-    private readonly store;
-    private readonly maxUsedRatio;
-    /** All resolved in `start()`, before anything that reads them can fire. */
-    private config;
-    private log;
-    private maxMemoryBytes;
-    private events?;
-    private maxMemoryRatio;
-    private lastLoggedCriticalMemoryOverloadAt;
     constructor(options?: MemoryLoadSignalOptions);
     start(context: LoadSignalStartContext): Promise<void>;
     stop(): Promise<void>;
     getSample(sampleDurationMillis?: number): LoadSnapshot[];
     /** @internal Records a snapshot from a `SYSTEM_INFO` payload. Exposed for tests. */
     handle(systemInfo: SystemInfo): void;
-    /** @internal */
-    _memoryOverloadWarning(systemInfo: SystemInfo, maxMemoryBytes?: number): void;
-    private _getTotalMemoryBytes;
+    private memoryOverloadWarning;
+    private getTotalMemoryBytes;
 }

package/autoscaling/memory_load_signal.js

@@ -1,3 +1,4 @@
+import { EventType } from '../events/event_manager.js';
 import { serviceLocator } from '../service_locator.js';
 import { getMemoryInfo } from '../system-info/memory-info.js';
 import { isContainerized } from '../system-info/runtime.js';
@@ -15,92 +16,91 @@ const CRITICAL_OVERLOAD_RATE_LIMIT_MILLIS = 10_000;
 export class MemoryLoadSignal {
     name = 'memInfo';
     overloadedRatio;
-    store = new SnapshotStore();
-    maxUsedRatio;
+    #store = new SnapshotStore();
+    #maxUsedRatio;
     /** All resolved in `start()`, before anything that reads them can fire. */
-    config;
-    log;
-    maxMemoryBytes;
-    events;
-    maxMemoryRatio;
-    lastLoggedCriticalMemoryOverloadAt = null;
+    #config;
+    #log;
+    #maxMemoryBytes;
+    #events;
+    #maxMemoryRatio;
+    #lastLoggedCriticalMemoryOverloadAt = null;
     constructor(options = {}) {
-        this.maxUsedRatio = options.maxUsedRatio ?? 0.9;
+        this.#maxUsedRatio = options.maxUsedRatio ?? 0.9;
         this.overloadedRatio = options.overloadedRatio ?? 0.2;
         this.handle = this.handle.bind(this);
     }
     async start(context) {
-        this.store.useSampleWindow(context.maxSampleWindowMillis);
+        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();
+        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;
+        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;
+            this.#maxMemoryBytes = memoryMbytes * 1024 * 1024;
         }
         else {
-            this.maxMemoryRatio = this.config.availableMemoryRatio;
-            if (!this.maxMemoryRatio) {
+            this.#maxMemoryRatio = this.#config.availableMemoryRatio;
+            if (!this.#maxMemoryRatio) {
                 throw new Error('availableMemoryRatio is not set in configuration.');
             }
             else {
-                this.log.debug(`Setting max memory of this run to ${this.maxMemoryRatio * 100} % of available memory. ` +
+                this.#log.debug(`Setting max memory of this run to ${this.#maxMemoryRatio * 100} % of available memory. ` +
                     'Use the CRAWLEE_MEMORY_MBYTES or CRAWLEE_AVAILABLE_MEMORY_RATIO environment variable to override it.');
             }
             // Fallback memory measurement in case memTotalBytes is missing from SystemInfo.
-            this.maxMemoryBytes = await this._getTotalMemoryBytes();
+            this.#maxMemoryBytes = await this.getTotalMemoryBytes();
         }
-        this.events.on("systemInfo" /* EventType.SYSTEM_INFO */, this.handle);
+        this.#events.on(EventType.SYSTEM_INFO, this.handle);
     }
     async stop() {
-        this.events?.off("systemInfo" /* EventType.SYSTEM_INFO */, this.handle);
-        this.events = undefined;
+        this.#events?.off(EventType.SYSTEM_INFO, this.handle);
+        this.#events = undefined;
     }
     getSample(sampleDurationMillis) {
-        return this.store.getSample(sampleDurationMillis);
+        return this.#store.getSample(sampleDurationMillis);
     }
     /** @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;
-        if (this.maxMemoryRatio !== undefined && this.maxMemoryRatio > 0) {
-            maxMemoryBytes = this.maxMemoryRatio * (memTotalBytes ?? this.maxMemoryBytes);
+        let maxMemoryBytes = this.#maxMemoryBytes;
+        if (this.#maxMemoryRatio !== undefined && this.#maxMemoryRatio > 0) {
+            maxMemoryBytes = this.#maxMemoryRatio * (memTotalBytes ?? this.#maxMemoryBytes);
         }
         const snapshot = {
             createdAt,
-            isOverloaded: memCurrentBytes / maxMemoryBytes > this.maxUsedRatio,
+            isOverloaded: memCurrentBytes / maxMemoryBytes > this.#maxUsedRatio,
             usedBytes: memCurrentBytes,
         };
-        this.store.push(snapshot, createdAt);
-        this._memoryOverloadWarning(systemInfo, maxMemoryBytes);
+        this.#store.push(snapshot, createdAt);
+        this.memoryOverloadWarning(systemInfo, maxMemoryBytes);
     }
-    /** @internal */
-    _memoryOverloadWarning(systemInfo, maxMemoryBytes) {
-        const effectiveMax = maxMemoryBytes ?? this.maxMemoryBytes;
+    memoryOverloadWarning(systemInfo, maxMemoryBytes) {
+        const effectiveMax = maxMemoryBytes ?? this.#maxMemoryBytes;
         const { memCurrentBytes } = systemInfo;
         const createdAt = systemInfo.createdAt ? new Date(systemInfo.createdAt) : new Date();
-        if (this.lastLoggedCriticalMemoryOverloadAt &&
-            +createdAt < +this.lastLoggedCriticalMemoryOverloadAt + CRITICAL_OVERLOAD_RATE_LIMIT_MILLIS)
+        if (this.#lastLoggedCriticalMemoryOverloadAt &&
+            +createdAt < +this.#lastLoggedCriticalMemoryOverloadAt + CRITICAL_OVERLOAD_RATE_LIMIT_MILLIS)
             return;
-        const maxDesiredMemoryBytes = this.maxUsedRatio * effectiveMax;
-        const reserveMemory = effectiveMax * (1 - this.maxUsedRatio) * 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) {
             const usedPercentage = Math.round((memCurrentBytes / effectiveMax) * 100);
             const toMb = (bytes) => Math.round(bytes / 1024 ** 2);
-            this.log.warning('Memory is critically overloaded. ' +
+            this.#log.warning('Memory is critically overloaded. ' +
                 `Using ${toMb(memCurrentBytes)} MB of ${toMb(effectiveMax)} MB (${usedPercentage}%). Consider increasing available memory.`);
-            this.lastLoggedCriticalMemoryOverloadAt = createdAt;
+            this.#lastLoggedCriticalMemoryOverloadAt = createdAt;
         }
     }
-    async _getTotalMemoryBytes() {
-        const containerized = this.config.containerized ?? (await isContainerized());
+    async getTotalMemoryBytes() {
+        const containerized = this.#config.containerized ?? (await isContainerized());
         return (await getMemoryInfo({ containerized, logger: serviceLocator.getLogger() })).totalBytes;
     }
 }

package/autoscaling/snapshotter.d.ts

@@ -1,8 +1,8 @@
-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';
+import type { StorageBackendLoadSignalOptions } from './storage_backend_load_signal.js';
 /**
  * The load signals a {@link ConcurrencySystem} watches to decide whether the machine is overloaded.
  *
@@ -31,11 +31,11 @@ export interface LoadSignalsOptions {
      */
     cpu?: CpuLoadSignalOptions | false;
     /**
-     * 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
+     * Tuning for the built-in {@link StorageBackendLoadSignal} (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.
      */
-    client?: ClientLoadSignalOptions | false;
+    storageBackend?: StorageBackendLoadSignalOptions | false;
     /**
      * 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
@@ -53,18 +53,15 @@ export interface LoadSignalsOptions {
 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.
+ * {@link EventLoopLoadSignal}, {@link CpuLoadSignal} and {@link StorageBackendLoadSignal} — constructing
+ * the ones that were not switched off and driving their shared lifecycle.
  *
  * Configured indirectly through {@link ConcurrencySystemOptions.loadSignals|`loadSignals`}, whose per-signal bags
  * are simply forwarded to the corresponding constructor.
  * @internal
  */
 export declare class Snapshotter {
-    private readonly memorySignal?;
-    private readonly eventLoopSignal?;
-    private readonly cpuSignal?;
-    private readonly clientSignal?;
+    #private;
     /**
      * 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

package/autoscaling/snapshotter.js

@@ -1,22 +1,22 @@
-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';
+import { StorageBackendLoadSignal } from './storage_backend_load_signal.js';
 /**
  * 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.
+ * {@link EventLoopLoadSignal}, {@link CpuLoadSignal} and {@link StorageBackendLoadSignal} — constructing
+ * the ones that were not switched off and driving their shared lifecycle.
  *
  * Configured indirectly through {@link ConcurrencySystemOptions.loadSignals|`loadSignals`}, whose per-signal bags
  * are simply forwarded to the corresponding constructor.
  * @internal
  */
 export class Snapshotter {
-    // Absent when switched off through the corresponding option (e.g. `client: false`).
-    memorySignal;
-    eventLoopSignal;
-    cpuSignal;
-    clientSignal;
+    // Absent when switched off through the corresponding option (e.g. `storageBackend: false`).
+    #memorySignal;
+    #eventLoopSignal;
+    #cpuSignal;
+    #storageBackendSignal;
     /**
      * 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
@@ -24,10 +24,10 @@ export class Snapshotter {
      */
     getLoadSignals() {
         const builtin = [
-            this.memorySignal,
-            this.eventLoopSignal,
-            this.cpuSignal,
-            this.clientSignal,
+            this.#memorySignal,
+            this.#eventLoopSignal,
+            this.#cpuSignal,
+            this.#storageBackendSignal,
         ];
         return builtin.filter((signal) => signal !== undefined);
     }
@@ -35,17 +35,17 @@ export class Snapshotter {
      * @param [options] All `Snapshotter` configuration options.
      */
     constructor(options = {}) {
-        const { memory = {}, eventLoop = {}, cpu = {}, client = {} } = options;
+        const { memory = {}, eventLoop = {}, cpu = {}, storageBackend = {} } = 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);
+            this.#memorySignal = new MemoryLoadSignal(memory);
         if (eventLoop !== false)
-            this.eventLoopSignal = new EventLoopLoadSignal(eventLoop);
+            this.#eventLoopSignal = new EventLoopLoadSignal(eventLoop);
         if (cpu !== false)
-            this.cpuSignal = new CpuLoadSignal(cpu);
-        if (client !== false)
-            this.clientSignal = new ClientLoadSignal(client);
+            this.#cpuSignal = new CpuLoadSignal(cpu);
+        if (storageBackend !== false)
+            this.#storageBackendSignal = new StorageBackendLoadSignal(storageBackend);
     }
     /**
      * Starts capturing snapshots at configured intervals. The `context` carries the sample window the signals will

package/autoscaling/{client_load_signal.d.ts → storage_backend_load_signal.d.ts}

@@ -1,18 +1,19 @@
 import type { LoadSignal, LoadSignalStartContext, LoadSnapshot } from './load_signal.js';
 /**
- * A snapshot produced by the built-in client (rate-limit) signal.
+ * A snapshot produced by the built-in storage backend (rate-limit) signal.
  * @internal
  */
-export interface ClientSnapshot extends LoadSnapshot {
+export interface StorageBackendSnapshot extends LoadSnapshot {
     rateLimitErrorCount: number;
 }
 /**
- * Tuning for the built-in **client** (rate-limit) load signal, as accepted both by {@link ClientLoadSignal} and by
- * the {@link LoadSignalsOptions.client|`client`} shorthand on {@link LoadSignalsOptions}.
+ * Tuning for the built-in **storage backend** (rate-limit) load signal, as accepted both by
+ * {@link StorageBackendLoadSignal} and by the
+ * {@link LoadSignalsOptions.storageBackend|`storageBackend`} shorthand on {@link LoadSignalsOptions}.
  */
-export interface ClientLoadSignalOptions {
+export interface StorageBackendLoadSignalOptions {
     /**
-     * Defines the interval of checking the current state of the remote API client, in seconds.
+     * Defines the interval of checking the current state of the storage backend, in seconds.
      * @default 1
      */
     snapshotIntervalSecs?: number;
@@ -22,7 +23,7 @@ export interface ClientLoadSignalOptions {
      */
     maxErrors?: number;
     /**
-     * Maximum ratio of overloaded snapshots in a sample before the client counts as overloaded.
+     * Maximum ratio of overloaded snapshots in a sample before the storage backend counts as overloaded.
      * @default 0.3
      */
     overloadedRatio?: number;
@@ -33,20 +34,16 @@ export interface ClientLoadSignalOptions {
  *
  * Built by default; construct one yourself only to wrap or adapt it — see {@link LoadSignal}.
  *
- * Switch it off entirely ({@link LoadSignalsOptions.client|`client: false`}) if the storage backend reports no
- * rate-limit statistics, since it otherwise polls it every second to no purpose.
+ * Switch it off entirely ({@link LoadSignalsOptions.storageBackend|`storageBackend: false`}) if the storage backend
+ * reports no rate-limit statistics, since it otherwise polls it every second to no purpose.
  *
  * @category Scaling
  */
-export declare class ClientLoadSignal implements LoadSignal {
-    readonly name = "clientInfo";
+export declare class StorageBackendLoadSignal implements LoadSignal {
+    #private;
+    readonly name = "storageBackendInfo";
     readonly overloadedRatio: number;
-    private readonly store;
-    private readonly intervalMillis;
-    private readonly maxErrors;
-    private interval?;
-    private client?;
-    constructor(options?: ClientLoadSignalOptions);
+    constructor(options?: StorageBackendLoadSignalOptions);
     start(context: LoadSignalStartContext): Promise<void>;
     stop(): Promise<void>;
     getSample(sampleDurationMillis?: number): LoadSnapshot[];

package/autoscaling/{client_load_signal.js → storage_backend_load_signal.js}

@@ -1,50 +1,50 @@
 import { betterClearInterval, betterSetInterval } from '@apify/utilities';
 import { serviceLocator } from '../service_locator.js';
 import { SnapshotStore } from './load_signal.js';
-const CLIENT_RATE_LIMIT_ERROR_RETRY_COUNT = 2;
+const RATE_LIMIT_ERROR_RETRY_COUNT = 2;
 /**
  * Periodically checks the storage backend for rate-limit errors (HTTP 429) and reports overload when the error delta
  * exceeds a threshold.
  *
  * Built by default; construct one yourself only to wrap or adapt it — see {@link LoadSignal}.
  *
- * Switch it off entirely ({@link LoadSignalsOptions.client|`client: false`}) if the storage backend reports no
- * rate-limit statistics, since it otherwise polls it every second to no purpose.
+ * Switch it off entirely ({@link LoadSignalsOptions.storageBackend|`storageBackend: false`}) if the storage backend
+ * reports no rate-limit statistics, since it otherwise polls it every second to no purpose.
  *
  * @category Scaling
  */
-export class ClientLoadSignal {
-    name = 'clientInfo';
+export class StorageBackendLoadSignal {
+    name = 'storageBackendInfo';
     overloadedRatio;
-    store = new SnapshotStore();
-    intervalMillis;
-    maxErrors;
-    interval;
-    client;
+    #store = new SnapshotStore();
+    #intervalMillis;
+    #maxErrors;
+    #interval;
+    #storageBackend;
     constructor(options = {}) {
         this.overloadedRatio = options.overloadedRatio ?? 0.3;
-        this.intervalMillis = (options.snapshotIntervalSecs ?? 1) * 1000;
-        this.maxErrors = options.maxErrors ?? 3;
+        this.#intervalMillis = (options.snapshotIntervalSecs ?? 1) * 1000;
+        this.#maxErrors = options.maxErrors ?? 3;
         this.handle = this.handle.bind(this);
     }
     async start(context) {
-        this.store.useSampleWindow(context.maxSampleWindowMillis);
+        this.#store.useSampleWindow(context.maxSampleWindowMillis);
         // A new session starts from a clean slate, or its first measurement diffs the error count against the previous
-        // session's — possibly against a different backend, since the client is resolved afresh just below.
-        this.store.clear();
+        // session's — possibly against a different backend, since it is resolved afresh just below.
+        this.#store.clear();
         // Resolved here rather than in the constructor, where asking for the backend would instantiate a default one
         // as a side effect - long before the crawler that owns the run has had a chance to register its own.
-        this.client = serviceLocator.getStorageBackend();
-        this.interval = betterSetInterval(this.handle, this.intervalMillis);
+        this.#storageBackend = serviceLocator.getStorageBackend();
+        this.#interval = betterSetInterval(this.handle, this.#intervalMillis);
     }
     async stop() {
-        if (this.interval)
-            betterClearInterval(this.interval);
-        this.interval = undefined;
-        this.client = undefined;
+        if (this.#interval)
+            betterClearInterval(this.#interval);
+        this.#interval = undefined;
+        this.#storageBackend = undefined;
     }
     getSample(sampleDurationMillis) {
-        return this.store.getSample(sampleDurationMillis);
+        return this.#store.getSample(sampleDurationMillis);
     }
     /**
      * Records one snapshot, overloaded when rate-limit errors grew by more than the configured limit since the
@@ -53,21 +53,21 @@ export class ClientLoadSignal {
      */
     handle(intervalCallback) {
         const now = new Date();
-        const allErrorCounts = this.client?.stats?.rateLimitErrors ?? [];
-        const currentErrCount = allErrorCounts[CLIENT_RATE_LIMIT_ERROR_RETRY_COUNT] || 0;
+        const allErrorCounts = this.#storageBackend?.stats?.rateLimitErrors ?? [];
+        const currentErrCount = allErrorCounts[RATE_LIMIT_ERROR_RETRY_COUNT] || 0;
         const snapshot = {
             createdAt: now,
             isOverloaded: false,
             rateLimitErrorCount: currentErrCount,
         };
-        const all = this.store.getAll();
+        const all = this.#store.getAll();
         const previousSnapshot = all[all.length - 1];
         if (previousSnapshot) {
             const delta = currentErrCount - previousSnapshot.rateLimitErrorCount;
-            if (delta > this.maxErrors)
+            if (delta > this.#maxErrors)
                 snapshot.isOverloaded = true;
         }
-        this.store.push(snapshot, now);
+        this.#store.push(snapshot, now);
         intervalCallback();
     }
 }

package/autoscaling/system_status.d.ts

@@ -6,10 +6,10 @@ import type { Snapshotter } from './snapshotter.js';
 export interface SystemInfo {
     /** If false, system is being overloaded. */
     isSystemIdle: boolean;
-    memInfo: ClientInfo;
-    eventLoopInfo: ClientInfo;
-    cpuInfo: ClientInfo;
-    clientInfo: ClientInfo;
+    memInfo: LoadSignalInfo;
+    eventLoopInfo: LoadSignalInfo;
+    cpuInfo: LoadSignalInfo;
+    storageBackendInfo: LoadSignalInfo;
     memTotalBytes?: number;
     memCurrentBytes?: number;
     /**
@@ -31,7 +31,7 @@ export interface SystemInfo {
      * Status of additional load signals beyond the built-in four.
      * Keys are `LoadSignal.name` values, values are overload info.
      */
-    loadSignalInfo?: Record<string, ClientInfo>;
+    loadSignalInfo?: Record<string, LoadSignalInfo>;
 }
 /**
  * How far back the *current* system status looks by default — the window that gates task dispatch.
@@ -69,12 +69,12 @@ export interface SystemStatusOptions {
     /**
      * 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. Each signal carries its own overload ratio.
+     * and storage backend signals. If any signal reports overload, the system
+     * is considered overloaded. Each signal carries its own overload ratio.
      */
     loadSignals?: LoadSignal[];
 }
-export interface ClientInfo {
+export interface LoadSignalInfo {
     isOverloaded: boolean;
     limitRatio: number;
     actualRatio: number;
@@ -105,9 +105,7 @@ export interface FinalStatistics {
  * @internal
  */
 export declare class SystemStatus {
-    private readonly currentHistoryMillis;
-    private readonly historyMillis;
-    private readonly signals;
+    #private;
     constructor(options: SystemStatusOptions);
     /**
      * The widest window any signal will be queried with, and therefore exactly how much history the signals are asked

package/autoscaling/system_status.js

@@ -15,7 +15,7 @@ const BUILTIN_SIGNAL_OPTION_KEYS = {
     memInfo: 'memory',
     eventLoopInfo: 'eventLoop',
     cpuInfo: 'cpu',
-    clientInfo: 'client',
+    storageBackendInfo: 'storageBackend',
 };
 const BUILTIN_SIGNAL_NAMES = new Set(Object.keys(BUILTIN_SIGNAL_OPTION_KEYS));
 /**
@@ -32,14 +32,14 @@ const BUILTIN_SIGNAL_NAMES = new Set(Object.keys(BUILTIN_SIGNAL_OPTION_KEYS));
  * @internal
  */
 export class SystemStatus {
-    currentHistoryMillis;
-    historyMillis;
-    signals;
+    #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.#currentHistoryMillis = currentHistorySecs * 1000;
+        this.#historyMillis = historySecs * 1000;
+        this.#signals = [...snapshotter.getLoadSignals(), ...loadSignals];
         this.assertUniqueSignalNames();
     }
     /**
@@ -48,7 +48,7 @@ export class SystemStatus {
      * defaults.
      */
     get maxSampleWindowMillis() {
-        return Math.max(this.currentHistoryMillis, this.historyMillis);
+        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
@@ -57,7 +57,7 @@ export class SystemStatus {
      */
     assertUniqueSignalNames() {
         const seen = new Set();
-        for (const { name } of this.signals) {
+        for (const { name } of this.#signals) {
             if (!seen.has(name)) {
                 seen.add(name);
                 continue;
@@ -85,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:
@@ -103,7 +103,7 @@ export class SystemStatus {
      * `historySecs` seconds and `true` otherwise.
      */
     getHistoricalStatus() {
-        return this.isSystemIdle(this.historyMillis);
+        return this.isSystemIdle(this.#historyMillis);
     }
     /**
      * Returns a system status object.
@@ -114,10 +114,10 @@ export class SystemStatus {
             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 },
+            storageBackendInfo: { isOverloaded: false, limitRatio: 0, actualRatio: 0 },
         };
         let loadSignalInfo;
-        for (const signal of this.signals) {
+        for (const signal of this.#signals) {
             const sample = signal.getSample(sampleDurationMillis);
             const info = evaluateLoadSignalSample(sample, signal.overloadedRatio);
             if (info.isOverloaded) {