@crawlee/core 4.0.0-beta.71 → 4.0.0-beta.73

package/autoscaling/snapshotter.d.ts

@@ -1,5 +1,11 @@
-import type { BetterIntervalID } from '@apify/utilities';
+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';
 import type { SystemInfo } from './system_status.js';
 export interface SnapshotterOptions {
     /**
@@ -28,41 +34,21 @@ export interface SnapshotterOptions {
     /**
      * Defines the maximum number of new rate limit errors within
      * the given interval.
-     * @default 1
+     * @default 3
      */
     maxClientErrors?: number;
     /**
      * 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 60
+     * @default 30
      */
     snapshotHistorySecs?: number;
     /** @internal */
     log?: CrawleeLogger;
-}
-interface MemorySnapshot {
-    createdAt: Date;
-    isOverloaded: boolean;
-    usedBytes?: number;
-}
-interface CpuSnapshot {
-    createdAt: Date;
-    isOverloaded: boolean;
-    usedRatio: number;
-    ticks?: {
-        idle: number;
-        total: number;
-    };
-}
-interface EventLoopSnapshot {
-    createdAt: Date;
-    isOverloaded: boolean;
-    exceededMillis: number;
-}
-interface ClientSnapshot {
-    createdAt: Date;
-    isOverloaded: boolean;
-    rateLimitErrorCount: number;
+    /** @internal */
+    client?: StorageBackend;
+    /** @internal */
+    config?: Configuration;
 }
 /**
  * Creates snapshots of system resources at given intervals and marks the resource
@@ -87,24 +73,26 @@ interface ClientSnapshot {
  *
  * 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
  */
 export declare class Snapshotter {
     log: CrawleeLogger;
-    eventLoopSnapshotIntervalMillis: number;
-    clientSnapshotIntervalMillis: number;
-    snapshotHistoryMillis: number;
-    maxBlockedMillis: number;
-    maxUsedMemoryRatio: number;
-    maxClientErrors: number;
-    maxMemoryBytes: number;
-    cpuSnapshots: CpuSnapshot[];
-    eventLoopSnapshots: EventLoopSnapshot[];
-    memorySnapshots: MemorySnapshot[];
-    clientSnapshots: ClientSnapshot[];
-    eventLoopInterval: BetterIntervalID;
-    clientInterval: BetterIntervalID;
-    lastLoggedCriticalMemoryOverloadAt: Date | null;
+    client: StorageBackend;
+    config: Configuration;
+    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.
+     */
+    getLoadSignals(): LoadSignal[];
+    get cpuSnapshots(): CpuSnapshot[];
+    get eventLoopSnapshots(): EventLoopSnapshot[];
+    get memorySnapshots(): MemorySnapshot[];
+    get clientSnapshots(): ClientSnapshot[];
     /**
      * @param [options] All `Snapshotter` configuration options.
      */
@@ -138,42 +126,27 @@ export declare class Snapshotter {
      */
     getClientSample(sampleDurationMillis?: number): ClientSnapshot[];
     /**
-     * Finds the latest snapshots by sampleDurationMillis in the provided array.
-     */
-    protected _getSample<T extends {
-        createdAt: Date;
-    }>(snapshots: T[], sampleDurationMillis?: number): T[];
-    /**
-     * Creates a snapshot of current memory usage
-     * using the Apify platform `systemInfo` event.
+     * @deprecated Kept for backward compatibility.
      */
     protected _snapshotMemory(systemInfo: SystemInfo): void;
     /**
-     * Checks for critical memory overload and logs it to the console.
+     * @deprecated Kept for backward compatibility.
      */
     protected _memoryOverloadWarning(systemInfo: SystemInfo): void;
     /**
-     * Creates a snapshot of current event loop delay.
+     * @deprecated Kept for backward compatibility.
      */
     protected _snapshotEventLoop(intervalCallback: () => unknown): void;
     /**
-     * Creates a snapshot of current CPU usage using the Apify platform `systemInfo` event.
+     * @deprecated Kept for backward compatibility.
      */
     protected _snapshotCpu(systemInfo: SystemInfo): void;
     /**
-     * Creates a snapshot of current API state by checking for
-     * rate limit errors. Only errors produced by a 2nd retry
-     * of the API call are considered for snapshotting since
-     * earlier errors may just be caused by a random spike in
-     * number of requests and do not necessarily signify API
-     * overloading.
+     * @deprecated Kept for backward compatibility.
      */
     protected _snapshotClient(intervalCallback: () => unknown): void;
     /**
-     * Removes snapshots that are older than the snapshotHistorySecs option
-     * from the array (destructively - in place).
+     * @deprecated Pruning is now handled by individual signals.
      */
-    protected _pruneSnapshots(snapshots: MemorySnapshot[] | CpuSnapshot[] | EventLoopSnapshot[] | ClientSnapshot[], now: Date): void;
+    protected _pruneSnapshots(_snapshots: any[], _now: Date): void;
 }
-export {};
-//# sourceMappingURL=snapshotter.d.ts.map

package/autoscaling/snapshotter.js

@@ -1,10 +1,9 @@
-import { getMemoryInfo, isContainerized } from '@crawlee/utils';
 import ow from 'ow';
-import { betterClearInterval, betterSetInterval } from '@apify/utilities';
 import { serviceLocator } from '../service_locator.js';
-const RESERVE_MEMORY_RATIO = 0.5;
-const CLIENT_RATE_LIMIT_ERROR_RETRY_COUNT = 2;
-const CRITICAL_OVERLOAD_RATE_LIMIT_MILLIS = 10000;
+import { createClientLoadSignal } from './client_load_signal.js';
+import { createCpuLoadSignal } from './cpu_load_signal.js';
+import { createEventLoopLoadSignal } 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.
@@ -28,24 +27,37 @@ const CRITICAL_OVERLOAD_RATE_LIMIT_MILLIS = 10000;
  *
  * 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
  */
 export class Snapshotter {
     log;
-    eventLoopSnapshotIntervalMillis;
-    clientSnapshotIntervalMillis;
-    snapshotHistoryMillis;
-    maxBlockedMillis;
-    maxUsedMemoryRatio;
-    maxClientErrors;
-    maxMemoryBytes;
-    cpuSnapshots = [];
-    eventLoopSnapshots = [];
-    memorySnapshots = [];
-    clientSnapshots = [];
-    eventLoopInterval = null;
-    clientInterval = null;
-    lastLoggedCriticalMemoryOverloadAt = null;
+    client;
+    config;
+    memorySignal;
+    eventLoopSignal;
+    cpuSignal;
+    clientSignal;
+    /**
+     * Returns the four built-in signals as an array, so `SystemStatus` can
+     * iterate them alongside any custom `LoadSignal` instances.
+     */
+    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();
+    }
     /**
      * @param [options] All `Snapshotter` configuration options.
      */
@@ -58,54 +70,53 @@ export class Snapshotter {
             maxUsedMemoryRatio: ow.optional.number,
             maxClientErrors: ow.optional.number,
             log: ow.optional.object,
+            client: ow.optional.object,
+            config: ow.optional.object,
         }));
-        const { eventLoopSnapshotIntervalSecs = 0.5, clientSnapshotIntervalSecs = 1, snapshotHistorySecs = 30, maxBlockedMillis = 50, maxUsedMemoryRatio = 0.9, maxClientErrors = 3, log = serviceLocator.getLogger(), } = options;
+        const { eventLoopSnapshotIntervalSecs = 0.5, clientSnapshotIntervalSecs = 1, snapshotHistorySecs = 30, maxBlockedMillis = 50, maxUsedMemoryRatio = 0.9, maxClientErrors = 3, log = serviceLocator.getLogger(), config = serviceLocator.getConfiguration(), client = serviceLocator.getStorageBackend(), } = options;
         this.log = log.child({ prefix: 'Snapshotter' });
-        this.eventLoopSnapshotIntervalMillis = eventLoopSnapshotIntervalSecs * 1000;
-        this.clientSnapshotIntervalMillis = clientSnapshotIntervalSecs * 1000;
-        this.snapshotHistoryMillis = snapshotHistorySecs * 1000;
-        this.maxBlockedMillis = maxBlockedMillis;
-        this.maxUsedMemoryRatio = maxUsedMemoryRatio;
-        this.maxClientErrors = maxClientErrors;
-        // We need to pre-bind those functions to be able to successfully remove listeners.
-        this._snapshotCpu = this._snapshotCpu.bind(this);
-        this._snapshotMemory = this._snapshotMemory.bind(this);
+        this.client = client;
+        this.config = config;
+        const snapshotHistoryMillis = snapshotHistorySecs * 1000;
+        this.memorySignal = new MemoryLoadSignal({
+            maxUsedMemoryRatio,
+            snapshotHistoryMillis,
+            config: this.config,
+            log: this.log,
+        });
+        this.eventLoopSignal = createEventLoopLoadSignal({
+            eventLoopSnapshotIntervalSecs,
+            maxBlockedMillis,
+            snapshotHistoryMillis,
+        });
+        this.cpuSignal = createCpuLoadSignal({
+            snapshotHistoryMillis,
+            config: this.config,
+        });
+        this.clientSignal = createClientLoadSignal({
+            client: this.client,
+            clientSnapshotIntervalSecs,
+            maxClientErrors,
+            snapshotHistoryMillis,
+        });
     }
     /**
      * Starts capturing snapshots at configured intervals.
      */
     async start() {
-        const memoryMbytes = serviceLocator.getConfiguration().memoryMbytes ?? 0;
-        if (memoryMbytes > 0) {
-            this.maxMemoryBytes = memoryMbytes * 1024 * 1024;
-        }
-        else {
-            const containerized = serviceLocator.getConfiguration().containerized ?? (await isContainerized());
-            const memInfo = await getMemoryInfo({
-                containerized,
-                logger: serviceLocator.getLogger(),
-            });
-            const totalBytes = memInfo.totalBytes;
-            this.maxMemoryBytes = Math.ceil(totalBytes * serviceLocator.getConfiguration().availableMemoryRatio);
-            this.log.debug(`Setting max memory of this run to ${Math.round(this.maxMemoryBytes / 1024 / 1024)} MB. ` +
-                'Use the CRAWLEE_MEMORY_MBYTES or CRAWLEE_AVAILABLE_MEMORY_RATIO environment variable to override it.');
-        }
-        // Start snapshotting.
-        this.eventLoopInterval = betterSetInterval(this._snapshotEventLoop.bind(this), this.eventLoopSnapshotIntervalMillis);
-        this.clientInterval = betterSetInterval(this._snapshotClient.bind(this), this.clientSnapshotIntervalMillis);
-        const events = serviceLocator.getEventManager();
-        events.on("systemInfo" /* EventType.SYSTEM_INFO */, this._snapshotCpu);
-        events.on("systemInfo" /* EventType.SYSTEM_INFO */, this._snapshotMemory);
+        await this.memorySignal.start();
+        await this.eventLoopSignal.start();
+        await this.cpuSignal.start();
+        await this.clientSignal.start();
     }
     /**
      * Stops all resource capturing.
      */
     async stop() {
-        betterClearInterval(this.eventLoopInterval);
-        betterClearInterval(this.clientInterval);
-        const events = serviceLocator.getEventManager();
-        events.off("systemInfo" /* EventType.SYSTEM_INFO */, this._snapshotCpu);
-        events.off("systemInfo" /* EventType.SYSTEM_INFO */, this._snapshotMemory);
+        await this.memorySignal.stop();
+        await this.eventLoopSignal.stop();
+        await this.cpuSignal.stop();
+        await this.clientSignal.stop();
         // Allow microtask queue to unwind before stop returns.
         await new Promise((resolve) => {
             setImmediate(resolve);
@@ -116,166 +127,63 @@ export class Snapshotter {
      * by the sampleDurationMillis parameter. If omitted, it returns a full snapshot history.
      */
     getMemorySample(sampleDurationMillis) {
-        return this._getSample(this.memorySnapshots, 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._getSample(this.eventLoopSnapshots, 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._getSample(this.cpuSnapshots, 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._getSample(this.clientSnapshots, sampleDurationMillis);
+        return this.clientSignal.getSample(sampleDurationMillis);
     }
     /**
-     * Finds the latest snapshots by sampleDurationMillis in the provided array.
-     */
-    _getSample(snapshots, sampleDurationMillis) {
-        if (!sampleDurationMillis)
-            return snapshots;
-        const sample = [];
-        let idx = snapshots.length;
-        if (!idx)
-            return sample;
-        const latestTime = snapshots[idx - 1].createdAt;
-        while (idx--) {
-            const snapshot = snapshots[idx];
-            if (+latestTime - +snapshot.createdAt <= sampleDurationMillis) {
-                sample.unshift(snapshot);
-            }
-            else {
-                break;
-            }
-        }
-        return sample;
-    }
-    /**
-     * Creates a snapshot of current memory usage
-     * using the Apify platform `systemInfo` event.
+     * @deprecated Kept for backward compatibility.
      */
     _snapshotMemory(systemInfo) {
-        const createdAt = systemInfo.createdAt ? new Date(systemInfo.createdAt) : new Date();
-        this._pruneSnapshots(this.memorySnapshots, createdAt);
-        const { memCurrentBytes } = systemInfo;
-        const snapshot = {
-            createdAt,
-            isOverloaded: memCurrentBytes / this.maxMemoryBytes > this.maxUsedMemoryRatio,
-            usedBytes: memCurrentBytes,
-        };
-        this.memorySnapshots.push(snapshot);
-        this._memoryOverloadWarning(systemInfo);
+        this.memorySignal._onSystemInfo(systemInfo);
     }
     /**
-     * Checks for critical memory overload and logs it to the console.
+     * @deprecated Kept for backward compatibility.
      */
     _memoryOverloadWarning(systemInfo) {
-        const { memCurrentBytes } = systemInfo;
-        const createdAt = systemInfo.createdAt ? new Date(systemInfo.createdAt) : new Date();
-        if (this.lastLoggedCriticalMemoryOverloadAt &&
-            +createdAt < +this.lastLoggedCriticalMemoryOverloadAt + CRITICAL_OVERLOAD_RATE_LIMIT_MILLIS)
-            return;
-        const maxDesiredMemoryBytes = this.maxUsedMemoryRatio * this.maxMemoryBytes;
-        const reserveMemory = this.maxMemoryBytes * (1 - this.maxUsedMemoryRatio) * RESERVE_MEMORY_RATIO;
-        const criticalOverloadBytes = maxDesiredMemoryBytes + reserveMemory;
-        const isCriticalOverload = memCurrentBytes > criticalOverloadBytes;
-        if (isCriticalOverload) {
-            const usedPercentage = Math.round((memCurrentBytes / this.maxMemoryBytes) * 100);
-            const toMb = (bytes) => Math.round(bytes / 1024 ** 2);
-            this.log.warning('Memory is critically overloaded. ' +
-                `Using ${toMb(memCurrentBytes)} MB of ${toMb(this.maxMemoryBytes)} MB (${usedPercentage}%). Consider increasing available memory.`);
-            this.lastLoggedCriticalMemoryOverloadAt = createdAt;
-        }
+        this.memorySignal._memoryOverloadWarning(systemInfo);
     }
     /**
-     * Creates a snapshot of current event loop delay.
+     * @deprecated Kept for backward compatibility.
      */
     _snapshotEventLoop(intervalCallback) {
-        const now = new Date();
-        this._pruneSnapshots(this.eventLoopSnapshots, now);
-        const snapshot = {
-            createdAt: now,
-            isOverloaded: false,
-            exceededMillis: 0,
-        };
-        const previousSnapshot = this.eventLoopSnapshots[this.eventLoopSnapshots.length - 1];
-        if (previousSnapshot) {
-            const { createdAt } = previousSnapshot;
-            const delta = now.getTime() - +createdAt - this.eventLoopSnapshotIntervalMillis;
-            if (delta > this.maxBlockedMillis)
-                snapshot.isOverloaded = true;
-            snapshot.exceededMillis = Math.max(delta - this.maxBlockedMillis, 0);
-        }
-        this.eventLoopSnapshots.push(snapshot);
-        intervalCallback();
+        this.eventLoopSignal.handle(intervalCallback);
     }
     /**
-     * Creates a snapshot of current CPU usage using the Apify platform `systemInfo` event.
+     * @deprecated Kept for backward compatibility.
      */
     _snapshotCpu(systemInfo) {
-        const { cpuCurrentUsage, isCpuOverloaded } = systemInfo;
-        const createdAt = systemInfo.createdAt ? new Date(systemInfo.createdAt) : new Date();
-        this._pruneSnapshots(this.cpuSnapshots, createdAt);
-        this.cpuSnapshots.push({
-            createdAt,
-            isOverloaded: isCpuOverloaded,
-            usedRatio: Math.ceil(cpuCurrentUsage / 100),
-        });
+        this.cpuSignal.handle(systemInfo);
     }
     /**
-     * Creates a snapshot of current API state by checking for
-     * rate limit errors. Only errors produced by a 2nd retry
-     * of the API call are considered for snapshotting since
-     * earlier errors may just be caused by a random spike in
-     * number of requests and do not necessarily signify API
-     * overloading.
+     * @deprecated Kept for backward compatibility.
      */
     _snapshotClient(intervalCallback) {
-        const now = new Date();
-        this._pruneSnapshots(this.clientSnapshots, now);
-        const allErrorCounts = serviceLocator.getStorageBackend().stats?.rateLimitErrors ?? []; // storage backend might not support this
-        const currentErrCount = allErrorCounts[CLIENT_RATE_LIMIT_ERROR_RETRY_COUNT] || 0;
-        // Handle empty snapshots array
-        const snapshot = {
-            createdAt: now,
-            isOverloaded: false,
-            rateLimitErrorCount: currentErrCount,
-        };
-        const previousSnapshot = this.clientSnapshots[this.clientSnapshots.length - 1];
-        if (previousSnapshot) {
-            const { rateLimitErrorCount } = previousSnapshot;
-            const delta = currentErrCount - rateLimitErrorCount;
-            if (delta > this.maxClientErrors)
-                snapshot.isOverloaded = true;
-        }
-        this.clientSnapshots.push(snapshot);
-        intervalCallback();
+        this.clientSignal.handle(intervalCallback);
     }
     /**
-     * Removes snapshots that are older than the snapshotHistorySecs option
-     * from the array (destructively - in place).
+     * @deprecated Pruning is now handled by individual signals.
      */
-    _pruneSnapshots(snapshots, now) {
-        let oldCount = 0;
-        for (let i = 0; i < snapshots.length; i++) {
-            const { createdAt } = snapshots[i];
-            if (now.getTime() - new Date(createdAt).getTime() > this.snapshotHistoryMillis)
-                oldCount++;
-            else
-                break;
-        }
-        snapshots.splice(0, oldCount);
+    _pruneSnapshots(_snapshots, _now) {
+        // no-op — signals prune themselves
     }
 }
-//# sourceMappingURL=snapshotter.js.map

package/autoscaling/system_status.d.ts

@@ -1,3 +1,4 @@
+import type { LoadSignal } from './load_signal.js';
 import { Snapshotter } from './snapshotter.js';
 /**
  * Represents the current status of the system.
@@ -9,6 +10,7 @@ export interface SystemInfo {
     eventLoopInfo: ClientInfo;
     cpuInfo: ClientInfo;
     clientInfo: ClientInfo;
+    memTotalBytes?: number;
     memCurrentBytes?: number;
     /**
      * Platform only property
@@ -25,6 +27,11 @@ export interface SystemInfo {
      * @internal
      */
     createdAt?: Date;
+    /**
+     * Status of additional load signals beyond the built-in four.
+     * Keys are `LoadSignal.name` values, values are overload info.
+     */
+    loadSignalInfo?: Record<string, ClientInfo>;
 }
 export interface SystemStatusOptions {
     /**
@@ -60,6 +67,13 @@ export interface SystemStatusOptions {
      * The `Snapshotter` instance to be queried for `SystemStatus`.
      */
     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.
+     */
+    loadSignals?: LoadSignal[];
 }
 export interface ClientInfo {
     isOverloaded: boolean;
@@ -102,11 +116,14 @@ export interface FinalStatistics {
  */
 export declare class SystemStatus {
     private readonly currentHistoryMillis;
-    private readonly maxMemoryOverloadedRatio;
-    private readonly maxEventLoopOverloadedRatio;
-    private readonly maxCpuOverloadedRatio;
-    private readonly maxClientOverloadedRatio;
     private readonly snapshotter;
+    private readonly signals;
+    /**
+     * Per-signal ratio overrides. The built-in four get their overrides from
+     * the legacy `max*OverloadedRatio` options; custom signals use their own
+     * `overloadedRatio`.
+     */
+    private ratioOverrides;
     constructor(options?: SystemStatusOptions);
     /**
      * Returns an {@link SystemInfo} object with the following structure:
@@ -146,33 +163,4 @@ export declare class SystemStatus {
      * Returns a system status object.
      */
     protected _isSystemIdle(sampleDurationMillis?: number): SystemInfo;
-    /**
-     * Returns an object with an isOverloaded property set to true
-     * if the memory has been overloaded in the last sampleDurationMillis.
-     */
-    protected _isMemoryOverloaded(sampleDurationMillis?: number): ClientInfo;
-    /**
-     * Returns an object with an isOverloaded property set to true
-     * if the event loop has been overloaded in the last sampleDurationMillis.
-     */
-    protected _isEventLoopOverloaded(sampleDurationMillis?: number): ClientInfo;
-    /**
-     * Returns an object with an isOverloaded property set to true
-     * if the CPU has been overloaded in the last sampleDurationMillis.
-     */
-    protected _isCpuOverloaded(sampleDurationMillis?: number): ClientInfo;
-    /**
-     * Returns an object with an isOverloaded property set to true
-     * if the client has been overloaded in the last sampleDurationMillis.
-     */
-    protected _isClientOverloaded(sampleDurationMillis?: number): ClientInfo;
-    /**
-     * 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.
-     */
-    protected _isSampleOverloaded<T extends {
-        createdAt: Date;
-        isOverloaded: boolean;
-    }>(sample: T[], ratio: number): ClientInfo;
 }
-//# sourceMappingURL=system_status.d.ts.map