261 lines
9.9 KiB
TypeScript
261 lines
9.9 KiB
TypeScript
import { QueueBase } from './queue-base';
|
|
import { Job } from './job';
|
|
import { JobState, JobType } from '../types';
|
|
import { JobJsonRaw, Metrics, QueueMeta } from '../interfaces';
|
|
/**
|
|
* Provides different getters for different aspects of a queue.
|
|
*/
|
|
export declare class QueueGetters<JobBase extends Job = Job> extends QueueBase {
|
|
getJob(jobId: string): Promise<JobBase | undefined>;
|
|
private commandByType;
|
|
private sanitizeJobTypes;
|
|
/**
|
|
Returns the number of jobs waiting to be processed. This includes jobs that are
|
|
"waiting" or "delayed" or "prioritized" or "waiting-children".
|
|
*/
|
|
count(): Promise<number>;
|
|
/**
|
|
* Returns the time to live for a rate limited key in milliseconds.
|
|
* @param maxJobs - max jobs to be considered in rate limit state. If not passed
|
|
* it will return the remaining ttl without considering if max jobs is excedeed.
|
|
* @returns -2 if the key does not exist.
|
|
* -1 if the key exists but has no associated expire.
|
|
* @see {@link https://redis.io/commands/pttl/}
|
|
*/
|
|
getRateLimitTtl(maxJobs?: number): Promise<number>;
|
|
/**
|
|
* Get jobId that starts debounced state.
|
|
* @deprecated use getDeduplicationJobId method
|
|
*
|
|
* @param id - debounce identifier
|
|
*/
|
|
getDebounceJobId(id: string): Promise<string | null>;
|
|
/**
|
|
* Get jobId from deduplicated state.
|
|
*
|
|
* @param id - deduplication identifier
|
|
*/
|
|
getDeduplicationJobId(id: string): Promise<string | null>;
|
|
/**
|
|
* Get global concurrency value.
|
|
* Returns null in case no value is set.
|
|
*/
|
|
getGlobalConcurrency(): Promise<number | null>;
|
|
/**
|
|
* Get global rate limit values.
|
|
* Returns null in case no value is set.
|
|
*/
|
|
getGlobalRateLimit(): Promise<{
|
|
max: number;
|
|
duration: number;
|
|
} | null>;
|
|
/**
|
|
* Job counts by type
|
|
*
|
|
* Queue#getJobCountByTypes('completed') =\> completed count
|
|
* Queue#getJobCountByTypes('completed', 'failed') =\> completed + failed count
|
|
* Queue#getJobCountByTypes('completed', 'waiting', 'failed') =\> completed + waiting + failed count
|
|
*/
|
|
getJobCountByTypes(...types: JobType[]): Promise<number>;
|
|
/**
|
|
* Returns the job counts for each type specified or every list/set in the queue by default.
|
|
*
|
|
* @returns An object, key (type) and value (count)
|
|
*/
|
|
getJobCounts(...types: JobType[]): Promise<{
|
|
[index: string]: number;
|
|
}>;
|
|
/**
|
|
* Get current job state.
|
|
*
|
|
* @param jobId - job identifier.
|
|
* @returns Returns one of these values:
|
|
* 'completed', 'failed', 'delayed', 'active', 'waiting', 'waiting-children', 'unknown'.
|
|
*/
|
|
getJobState(jobId: string): Promise<JobState | 'unknown'>;
|
|
/**
|
|
* Get global queue configuration.
|
|
*
|
|
* @returns Returns the global queue configuration.
|
|
*/
|
|
getMeta(): Promise<QueueMeta>;
|
|
/**
|
|
* @returns Returns the number of jobs in completed status.
|
|
*/
|
|
getCompletedCount(): Promise<number>;
|
|
/**
|
|
* Returns the number of jobs in failed status.
|
|
*/
|
|
getFailedCount(): Promise<number>;
|
|
/**
|
|
* Returns the number of jobs in delayed status.
|
|
*/
|
|
getDelayedCount(): Promise<number>;
|
|
/**
|
|
* Returns the number of jobs in active status.
|
|
*/
|
|
getActiveCount(): Promise<number>;
|
|
/**
|
|
* Returns the number of jobs in prioritized status.
|
|
*/
|
|
getPrioritizedCount(): Promise<number>;
|
|
/**
|
|
* Returns the number of jobs per priority.
|
|
*/
|
|
getCountsPerPriority(priorities: number[]): Promise<{
|
|
[index: string]: number;
|
|
}>;
|
|
/**
|
|
* Returns the number of jobs in waiting or paused statuses.
|
|
*/
|
|
getWaitingCount(): Promise<number>;
|
|
/**
|
|
* Returns the number of jobs in waiting-children status.
|
|
*/
|
|
getWaitingChildrenCount(): Promise<number>;
|
|
/**
|
|
* Returns the jobs that are in the "waiting" status.
|
|
* @param start - zero based index from where to start returning jobs.
|
|
* @param end - zero based index where to stop returning jobs.
|
|
*/
|
|
getWaiting(start?: number, end?: number): Promise<JobBase[]>;
|
|
/**
|
|
* Returns the jobs that are in the "waiting-children" status.
|
|
* I.E. parent jobs that have at least one child that has not completed yet.
|
|
* @param start - zero based index from where to start returning jobs.
|
|
* @param end - zero based index where to stop returning jobs.
|
|
*/
|
|
getWaitingChildren(start?: number, end?: number): Promise<JobBase[]>;
|
|
/**
|
|
* Returns the jobs that are in the "active" status.
|
|
* @param start - zero based index from where to start returning jobs.
|
|
* @param end - zero based index where to stop returning jobs.
|
|
*/
|
|
getActive(start?: number, end?: number): Promise<JobBase[]>;
|
|
/**
|
|
* Returns the jobs that are in the "delayed" status.
|
|
* @param start - zero based index from where to start returning jobs.
|
|
* @param end - zero based index where to stop returning jobs.
|
|
*/
|
|
getDelayed(start?: number, end?: number): Promise<JobBase[]>;
|
|
/**
|
|
* Returns the jobs that are in the "prioritized" status.
|
|
* @param start - zero based index from where to start returning jobs.
|
|
* @param end - zero based index where to stop returning jobs.
|
|
*/
|
|
getPrioritized(start?: number, end?: number): Promise<JobBase[]>;
|
|
/**
|
|
* Returns the jobs that are in the "completed" status.
|
|
* @param start - zero based index from where to start returning jobs.
|
|
* @param end - zero based index where to stop returning jobs.
|
|
*/
|
|
getCompleted(start?: number, end?: number): Promise<JobBase[]>;
|
|
/**
|
|
* Returns the jobs that are in the "failed" status.
|
|
* @param start - zero based index from where to start returning jobs.
|
|
* @param end - zero based index where to stop returning jobs.
|
|
*/
|
|
getFailed(start?: number, end?: number): Promise<JobBase[]>;
|
|
/**
|
|
* Returns the qualified job ids and the raw job data (if available) of the
|
|
* children jobs of the given parent job.
|
|
* It is possible to get either the already processed children, in this case
|
|
* an array of qualified job ids and their result values will be returned,
|
|
* or the pending children, in this case an array of qualified job ids will
|
|
* be returned.
|
|
* A qualified job id is a string representing the job id in a given queue,
|
|
* for example: "bull:myqueue:jobid".
|
|
*
|
|
* @param parentId - The id of the parent job
|
|
* @param type - "processed" | "pending"
|
|
* @param opts - Options for the query.
|
|
*
|
|
* @returns an object with the following shape:
|
|
* `{ items: { id: string, v?: any, err?: string } [], jobs: JobJsonRaw[], total: number}`
|
|
*/
|
|
getDependencies(parentId: string, type: 'processed' | 'pending', start: number, end: number): Promise<{
|
|
items: {
|
|
id: string;
|
|
v?: any;
|
|
err?: string;
|
|
}[];
|
|
jobs: JobJsonRaw[];
|
|
total: number;
|
|
}>;
|
|
getRanges(types: JobType[], start?: number, end?: number, asc?: boolean): Promise<string[]>;
|
|
/**
|
|
* Returns the jobs that are on the given statuses (note that JobType is synonym for job status)
|
|
* @param types - the statuses of the jobs to return.
|
|
* @param start - zero based index from where to start returning jobs.
|
|
* @param end - zero based index where to stop returning jobs.
|
|
* @param asc - if true, the jobs will be returned in ascending order.
|
|
*/
|
|
getJobs(types?: JobType[] | JobType, start?: number, end?: number, asc?: boolean): Promise<JobBase[]>;
|
|
/**
|
|
* Returns the logs for a given Job.
|
|
* @param jobId - the id of the job to get the logs for.
|
|
* @param start - zero based index from where to start returning jobs.
|
|
* @param end - zero based index where to stop returning jobs.
|
|
* @param asc - if true, the jobs will be returned in ascending order.
|
|
*/
|
|
getJobLogs(jobId: string, start?: number, end?: number, asc?: boolean): Promise<{
|
|
logs: string[];
|
|
count: number;
|
|
}>;
|
|
private baseGetClients;
|
|
/**
|
|
* Get the worker list related to the queue. i.e. all the known
|
|
* workers that are available to process jobs for this queue.
|
|
* Note: GCP does not support SETNAME, so this call will not work
|
|
*
|
|
* @returns - Returns an array with workers info.
|
|
*/
|
|
getWorkers(): Promise<{
|
|
[index: string]: string;
|
|
}[]>;
|
|
/**
|
|
* Returns the current count of workers for the queue.
|
|
*
|
|
* getWorkersCount(): Promise<number>
|
|
*
|
|
*/
|
|
getWorkersCount(): Promise<number>;
|
|
/**
|
|
* Get queue events list related to the queue.
|
|
* Note: GCP does not support SETNAME, so this call will not work
|
|
*
|
|
* @deprecated do not use this method, it will be removed in the future.
|
|
*
|
|
* @returns - Returns an array with queue events info.
|
|
*/
|
|
getQueueEvents(): Promise<{
|
|
[index: string]: string;
|
|
}[]>;
|
|
/**
|
|
* Get queue metrics related to the queue.
|
|
*
|
|
* This method returns the gathered metrics for the queue.
|
|
* The metrics are represented as an array of job counts
|
|
* per unit of time (1 minute).
|
|
*
|
|
* @param start - Start point of the metrics, where 0
|
|
* is the newest point to be returned.
|
|
* @param end - End point of the metrics, where -1 is the
|
|
* oldest point to be returned.
|
|
*
|
|
* @returns - Returns an object with queue metrics.
|
|
*/
|
|
getMetrics(type: 'completed' | 'failed', start?: number, end?: number): Promise<Metrics>;
|
|
private parseClientList;
|
|
/**
|
|
* Export the metrics for the queue in the Prometheus format.
|
|
* Automatically exports all the counts returned by getJobCounts().
|
|
*
|
|
* @returns - Returns a string with the metrics in the Prometheus format.
|
|
*
|
|
* @see {@link https://prometheus.io/docs/instrumenting/exposition_formats/}
|
|
*
|
|
**/
|
|
exportPrometheusMetrics(globalVariables?: Record<string, string>): Promise<string>;
|
|
}
|