bullmq 1.75.1 → 1.76.0

package/dist/bullmq.d.ts

@@ -8,6 +8,8 @@ import { Pipeline } from 'ioredis';
 import { Redis } from 'ioredis';
 import { RedisOptions as RedisOptions_2 } from 'ioredis';
 
+export declare type ActiveEventCallback3<T = any> = (job: Job, jobPromise?: JobPromise3) => void;
+
 export declare interface AddChildrenOpts {
     multi: Pipeline;
     nodes: FlowJob[];
@@ -112,8 +114,34 @@ export declare interface ChildProcessExt extends ChildProcess {
     processFile?: string;
 }
 
+/**
+ * ChildProcessor
+ *
+ * This class acts as the interface between a child process and it parent process
+ * so that jobs can be processed in different processes than the parent.
+ *
+ */
+export declare class ChildProcessor {
+    status: ChildStatus;
+    processor: any;
+    currentJobPromise: Promise<unknown> | undefined;
+    init(processorFile: string): Promise<void>;
+    start(jobJson: JobJson): Promise<void>;
+    stop(): Promise<void>;
+    waitForCurrentJobAndExit(): Promise<void>;
+}
+
 export declare const childSend: (proc: NodeJS.Process, msg: ChildMessage) => Promise<void>;
 
+declare enum ChildStatus {
+    Idle = 0,
+    Started = 1,
+    Terminating = 2,
+    Errored = 3
+}
+
+export declare type CleanedEventCallback3<T = any> = (jobs: Array<Job>, status: JobStatusClean3) => void;
+
 export declare const clientCommandMessageReg: RegExp;
 
 export declare enum ClientType {
@@ -129,6 +157,10 @@ export declare interface Command {
     };
 }
 
+declare type CommonOptions = QueueSchedulerOptions & QueueOptions & WorkerOptions & QueueEventsOptions;
+
+export declare type CompletedEventCallback3<T = any> = (job: Job, result: any) => void;
+
 export declare type ConnectionOptions = RedisOptions | Redis | Cluster;
 
 export declare function delay(ms: number): Promise<void>;
@@ -160,10 +192,16 @@ export declare enum ErrorCode {
     ParentJobNotExist = -5
 }
 
+export declare type ErrorEventCallback3 = (error: Error) => void;
+
 export declare const errorObject: {
     [index: string]: any;
 };
 
+export declare type EventCallback3 = () => void;
+
+export declare type FailedEventCallback3<T = any> = (job: Job, error: Error) => void;
+
 export declare type FinishedPropValAttribute = 'returnvalue' | 'failedReason';
 
 export declare type FinishedStatus = 'completed' | 'failed';
@@ -599,6 +637,16 @@ export declare type JobData = [JobJsonRaw | number, string?];
 
 export declare function jobIdForGroup(jobOpts: JobsOptions, data: any, queueOpts: QueueOptions): string;
 
+export declare interface JobInformation3 {
+    key: string;
+    name: string;
+    id?: string;
+    endDate?: number;
+    tz?: string;
+    cron: string;
+    next: number;
+}
+
 export declare interface JobJson {
     id: string;
     name: string;
@@ -643,6 +691,13 @@ export declare interface JobNode {
     children?: JobNode[];
 }
 
+export declare interface JobPromise3 {
+    /**
+     * Abort this job
+     */
+    cancel(): void;
+}
+
 export declare interface JobsOptions {
     /**
      * Timestamp when the job was created. Defaults to `Date.now()`.
@@ -737,6 +792,8 @@ export declare interface JobsOptions {
 
 export declare type JobState = FinishedStatus | 'active' | 'delayed' | 'waiting' | 'waiting-children';
 
+export declare type JobStatusClean3 = 'completed' | 'wait' | 'active' | 'delayed' | 'paused' | 'failed';
+
 export declare type JobType = JobState | 'paused' | 'repeat' | 'wait';
 
 /**
@@ -757,10 +814,16 @@ export declare interface KeepJobs {
     count?: number;
 }
 
-declare type KeysMap = {
+export declare type KeysMap = {
     [index in string]: string;
 };
 
+/**
+ * Sends a kill signal to a child resolving when the child has exited,
+ * resorting to SIGKILL if the given timeout is reached
+ */
+export declare function killAsync(child: ChildProcess, signal?: 'SIGTERM' | 'SIGKILL', timeoutMs?: number): Promise<void>;
+
 /**
  * Checks the size of string for ascii/non-ascii characters
  * @see https://stackoverflow.com/a/23318053/1347170
@@ -768,6 +831,40 @@ declare type KeysMap = {
  */
 export declare function lengthInUtf8Bytes(str: string): number;
 
+export declare interface Metrics {
+    meta: {
+        count: number;
+        prevTS: number;
+        prevCount: number;
+    };
+    data: number[];
+    count: number;
+}
+
+/**
+ *
+ *
+ */
+export declare interface MetricsOptions {
+    /**
+     * Enable gathering metrics for finished jobs.
+     * Output refers to all finished jobs, completed or
+     * failed.
+     */
+    maxDataPoints?: number;
+}
+
+export declare enum MetricsTime {
+    ONE_MINUTE = 1,
+    FIVE_MINUTES = 5,
+    FIFTEEN_MINUTES = 15,
+    THIRTY_MINUTES = 30,
+    ONE_HOUR = 60,
+    ONE_WEEK = 10080,
+    TWO_WEEKS = 20160,
+    ONE_MONTH = 80640
+}
+
 export declare type MinimalQueue = Pick<QueueBase, 'name' | 'client' | 'toKey' | 'keys' | 'opts' | 'closing' | 'waitUntilReady' | 'removeListener' | 'emit' | 'on' | 'redisVersion'>;
 
 export declare interface MoveToChildrenOpts {
@@ -866,6 +963,8 @@ declare interface procSendLike {
     }, callback?: (error: Error) => void): boolean;
 }
 
+export declare type ProgressEventCallback3<T = any> = (job: Job, progress: any) => void;
+
 /**
  * Queue
  *
@@ -1011,6 +1110,293 @@ export declare class Queue<DataType = any, ResultType = any, NameType extends st
     trimEvents(maxLength: number): Promise<number>;
 }
 
+/**
+ * @deprecated Use Queue class instead {@link https://docs.bullmq.io/guide/queues}
+ */
+export declare class Queue3<T = any> extends EventEmitter {
+    /**
+     * The name of the queue
+     */
+    name: string;
+    queueEvents: QueueEvents;
+    private opts;
+    private readonly queue;
+    private worker;
+    private queueScheduler;
+    /**
+     * This is the Queue constructor.
+     * It creates a new Queue that is persisted in Redis.
+     * Every time the same queue is instantiated it tries to process all the old jobs
+     * that may exist from a previous unfinished session.
+     */
+    constructor(name: string, opts?: CommonOptions);
+    /**
+     * Returns a promise that resolves when Redis is connected and the queue is ready to accept jobs.
+     * This replaces the `ready` event emitted on Queue in previous versions.
+     */
+    isReady(): Promise<this>;
+    /**
+     * Defines a processing function for the jobs placed into a given Queue.
+     *
+     * The callback is called every time a job is placed in the queue.
+     * It is passed an instance of the job as first argument.
+     *
+     * If the callback signature contains the second optional done argument,
+     * the callback will be passed a done callback to be called after the job has been completed.
+     * The done callback can be called with an Error instance, to signal that the job did not complete successfully,
+     * or with a result as second argument (e.g.: done(null, result);) when the job is successful.
+     * Errors will be passed as a second argument to the "failed" event; results,
+     * as a second argument to the "completed" event.
+     *
+     * If, however, the callback signature does not contain the done argument,
+     * a promise must be returned to signal job completion.
+     * If the promise is rejected, the error will be passed as a second argument to the "failed" event.
+     * If it is resolved, its value will be the "completed" event's second argument.
+     */
+    process(processor: string | Processor<T>): Promise<void>;
+    add(jobName: string, data: any, opts?: JobsOptions): Promise<Job>;
+    /**
+     * Returns a promise that resolves when the queue is paused.
+     *
+     * A paused queue will not process new jobs until resumed, but current jobs being processed will continue until
+     * they are finalized. The pause can be either global or local. If global, all workers in all queue instances
+     * for a given queue will be paused. If local, just this worker will stop processing new jobs after the current
+     * lock expires. This can be useful to stop a worker from taking new jobs prior to shutting down.
+     *
+     * Pausing a queue that is already paused does nothing.
+     */
+    pause(): Promise<void>;
+    pauseWorker(doNotWaitActive?: boolean): Promise<void>;
+    /**
+     * Returns a promise that resolves when the queue is resumed after being paused.
+     *
+     * The resume can be either local or global. If global, all workers in all queue instances for a given queue
+     * will be resumed. If local, only this worker will be resumed. Note that resuming a queue globally will not
+     * resume workers that have been paused locally; for those, resume(true) must be called directly on their
+     * instances.
+     *
+     * Resuming a queue that is not paused does nothing.
+     */
+    resume(): Promise<void>;
+    resumeWorker(): Promise<void>;
+    isWorkerPaused(): boolean;
+    /**
+     * Returns a promise that returns the number of jobs in the queue, waiting or paused.
+     * Since there may be other processes adding or processing jobs,
+     * this value may be true only for a very small amount of time.
+     */
+    count(): Promise<number>;
+    /**
+     * Empties a queue deleting all the input lists and associated jobs.
+     */
+    empty(): Promise<void>;
+    /**
+     * Closes the underlying redis client. Use this to perform a graceful shutdown.
+     *
+     * `close` can be called from anywhere, with one caveat:
+     * if called from within a job handler the queue won't close until after the job has been processed
+     */
+    close(): Promise<any>;
+    /**
+     * Returns a promise that will return the job instance associated with the jobId parameter.
+     * If the specified job cannot be located, the promise callback parameter will be set to null.
+     */
+    getJob(jobId: string): Promise<Job | null>;
+    /**
+     * Returns a promise that will return an array with the waiting jobs between start and end.
+     */
+    getWaiting(start?: number, end?: number): Promise<Array<Job>>;
+    /**
+     * Returns a promise that will return an array with the active jobs between start and end.
+     */
+    getActive(start?: number, end?: number): Promise<Array<Job>>;
+    /**
+     * Returns a promise that will return an array with the delayed jobs between start and end.
+     */
+    getDelayed(start?: number, end?: number): Promise<Array<Job>>;
+    /**
+     * Returns a promise that will return an array with the completed jobs between start and end.
+     */
+    getCompleted(start?: number, end?: number): Promise<Array<Job>>;
+    /**
+     * Returns a promise that will return an array with the failed jobs between start and end.
+     */
+    getFailed(start?: number, end?: number): Promise<Array<Job>>;
+    /**
+     * Returns JobInformation of repeatable jobs (ordered descending). Provide a start and/or an end
+     * index to limit the number of results. Start defaults to 0, end to -1 and asc to false.
+     */
+    getRepeatableJobs(start?: number, end?: number, asc?: boolean): Promise<JobInformation3[]>;
+    /**
+     * ???
+     */
+    nextRepeatableJob(name: string, data: any, opts?: JobsOptions, skipCheckExists?: boolean): Promise<Job>;
+    /**
+     * Removes a given repeatable job. The RepeatOptions and JobId needs to be the same as the ones
+     * used for the job when it was added.
+     *
+     * name: The name of the to be removed job
+     */
+    removeRepeatable(name: string, opts: RepeatOptions): Promise<void>;
+    /**
+     * Removes a given repeatable job by key.
+     */
+    removeRepeatableByKey(repeatJobKey: string): Promise<void>;
+    /**
+     * Returns a promise that will return an array of job instances of the given types.
+     * Optional parameters for range and ordering are provided.
+     */
+    getJobs(types: JobType[] | JobType, start?: number, end?: number, asc?: boolean): Promise<Array<Job>>;
+    getNextJob(): Promise<Job>;
+    /**
+     * Returns a object with the logs according to the start and end arguments. The returned count
+     * value is the total amount of logs, useful for implementing pagination.
+     */
+    getJobLogs(jobId: string, start?: number, end?: number): Promise<{
+        logs: string[];
+        count: number;
+    }>;
+    /**
+     * Returns a promise that resolves with the job counts for the given queue.
+     */
+    getJobCounts(...types: JobType[]): Promise<{
+        [index: string]: number;
+    }>;
+    /**
+     * Returns a promise that resolves with the job counts for the given queue of the given types.
+     */
+    getJobCountByTypes(...types: JobType[]): Promise<number>;
+    /**
+     * Returns a promise that resolves with the quantity of completed jobs.
+     */
+    getCompletedCount(): Promise<number>;
+    /**
+     * Returns a promise that resolves with the quantity of failed jobs.
+     */
+    getFailedCount(): Promise<number>;
+    /**
+     * Returns a promise that resolves with the quantity of delayed jobs.
+     */
+    getDelayedCount(): Promise<number>;
+    /**
+     * Returns a promise that resolves with the quantity of waiting jobs.
+     */
+    getWaitingCount(): Promise<number>;
+    /**
+     * Returns a promise that resolves with the quantity of paused jobs.
+     */
+    getPausedCount(): Promise<number>;
+    /**
+     * Returns a promise that resolves with the quantity of active jobs.
+     */
+    getActiveCount(): Promise<number>;
+    /**
+     * Returns a promise that resolves to the quantity of repeatable jobs.
+     */
+    getRepeatableCount(): Promise<number>;
+    /**
+     * Tells the queue remove all jobs created outside of a grace period in milliseconds.
+     * You can clean the jobs with the following states: completed, wait (typo for waiting), active, delayed, and failed.
+     * @param grace - Grace period in milliseconds.
+     * @param limit - Maximum amount of jobs to clean per call. If not provided will clean all matching jobs.
+     * @param type - Status of the job to clean. Values are completed, wait,
+     * active, paused, delayed, and failed. Defaults to completed.
+     */
+    clean(grace: number, limit: number, type?: 'completed' | 'wait' | 'active' | 'paused' | 'delayed' | 'failed'): Promise<string[]>;
+    /**
+     * Listens to queue events
+     */
+    on(event: string, callback: (...args: any[]) => void): this;
+    /**
+     * An error occurred
+     */
+    on(event: 'error', callback: ErrorEventCallback3): this;
+    /**
+     * A Job is waiting to be processed as soon as a worker is idling.
+     */
+    on(event: 'waiting', callback: WaitingEventCallback3): this;
+    /**
+     * A job has started. You can use `jobPromise.cancel()` to abort it
+     */
+    on(event: 'active', callback: ActiveEventCallback3<T>): this;
+    /**
+     * A job has been marked as stalled.
+     * This is useful for debugging job workers that crash or pause the event loop.
+     */
+    on(event: 'stalled', callback: StalledEventCallback3<T>): this;
+    /**
+     * A job's progress was updated
+     */
+    on(event: 'progress', callback: ProgressEventCallback3<T>): this;
+    /**
+     * A job successfully completed with a `result`
+     */
+    on(event: 'completed', callback: CompletedEventCallback3<T>): this;
+    /**
+     * A job failed with `err` as the reason
+     */
+    on(event: 'failed', callback: FailedEventCallback3<T>): this;
+    /**
+     * The queue has been paused
+     */
+    on(event: 'paused', callback: EventCallback3): this;
+    /**
+     * The queue has been resumed
+     */
+    on(event: 'resumed', callback: EventCallback3): this;
+    /**
+     * A job successfully removed.
+     */
+    on(event: 'removed', callback: RemovedEventCallback3<T>): this;
+    /**
+     * Old jobs have been cleaned from the queue.
+     * `jobs` is an array of jobs that were removed, and `type` is the type of those jobs.
+     *
+     * @see Queue#clean() for details
+     */
+    on(event: 'cleaned', callback: CleanedEventCallback3<T>): this;
+    /**
+     * Emitted every time the queue has processed all the waiting jobs
+     * (even if there can be some delayed jobs not yet processed)
+     */
+    on(event: 'drained', callback: EventCallback3): this;
+    once(event: string | symbol, listener: (...args: any[]) => void): this;
+    off(event: string | symbol, listener?: (...args: any[]) => void): this;
+    removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+    removeAllListeners(event: string | symbol): this;
+    /**
+     * Set clientName to Redis.client
+     */
+    setWorkerName(): Promise<any>;
+    /**
+     * Returns Redis clients array which belongs to current Queue
+     */
+    getWorkers(): Promise<{
+        [key: string]: string;
+    }[]>;
+    /**
+     * Returns Queue name in base64 encoded format
+     */
+    base64Name(): string;
+    /**
+     * Returns Queue name with keyPrefix (default: 'bull')
+     */
+    clientName(): string;
+    /**
+     * Returns Redis clients array which belongs to current Queue from string with all redis clients
+     *
+     * @param list - String with all redis clients
+     */
+    parseClientList(list: string): {
+        [key: string]: string;
+    }[];
+    retryJob(job: Job): Promise<void>;
+    private getQueueEvents;
+    private ensureWorkerCreated;
+    private attachListener;
+    detachListener(event: string | symbol, listener?: (...args: any[]) => void): this;
+}
+
 export declare class QueueBase extends EventEmitter {
     readonly name: string;
     opts: QueueBaseOptions;
@@ -1286,10 +1672,25 @@ export declare class QueueGetters<DataType, ResultType, NameType extends string>
     getQueueSchedulers(): 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 poinf 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;
 }
 
-declare class QueueKeys {
+export declare class QueueKeys {
     readonly prefix: string;
     constructor(prefix?: string);
     getKeys(name: string): KeysMap;
@@ -1513,6 +1914,8 @@ export declare type RedisOptions = (RedisOptions_2 | ClusterOptions) & {
 
 export declare function removeAllQueueData(client: RedisClient, queueName: string, prefix?: string): Promise<void | boolean>;
 
+export declare type RemovedEventCallback3<T = any> = (job: Job) => void;
+
 export declare class Repeat extends QueueBase {
     addNextRepeatableJob<T = any, R = any, N extends string = string>(name: N, data: T, opts: JobsOptions, skipCheckExists?: boolean): Promise<Job<T, R, N>>;
     private createNextJob;
@@ -1793,6 +2196,8 @@ export declare class Scripts {
     }): Promise<number>;
 }
 
+export declare type StalledEventCallback3<T = any> = (job: Job) => void;
+
 export declare interface Strategies {
     [index: string]: BackoffFunction;
 }
@@ -1805,7 +2210,7 @@ export declare type StreamReadRaw = [StreamName, EntryRaw[]][];
  * Keeps track on timers created with setTimeout to help clearTimeout
  * for all timers when no more delayed actions needed
  */
-declare class TimerManager {
+export declare class TimerManager {
     private readonly timers;
     /**
      * Creates a new timer and returns its ID.
@@ -1832,6 +2237,8 @@ export declare class UnrecoverableError extends Error {
     constructor(message?: string);
 }
 
+export declare type WaitingEventCallback3 = (jobId: string) => void;
+
 /**
  *
  * This class represents a worker that is able to process jobs from the queue.
@@ -2009,9 +2416,15 @@ export declare interface WorkerOptions extends QueueBaseOptions {
      */
     concurrency?: number;
     /**
+     * Enable rate limiter
      * @see {@link https://docs.bullmq.io/guide/rate-limiting}
      */
     limiter?: RateLimiterOptions;
+    /**
+     * Enable collect metrics.
+     * @see {@link https://docs.bullmq.io/guide/metrics}
+     */
+    metrics?: MetricsOptions;
     skipDelayCheck?: boolean;
     drainDelay?: number;
     lockDuration?: number;

package/dist/cjs/classes/index.d.ts

@@ -1,15 +1,21 @@
 export * from './backoffs';
+export * from './child-pool';
+export * from './child-processor';
+export * from './compat';
+export * from './flow-producer';
 export * from './job';
+export * from './master';
+export * from './process-utils';
 export * from './queue-base';
 export * from './queue-events';
 export * from './queue-getters';
+export * from './queue-keys';
 export * from './queue-scheduler';
 export * from './queue';
 export * from './redis-connection';
 export * from './repeat';
-export * from './scripts';
-export * from './worker';
-export * from './child-pool';
 export * from './sandbox';
-export * from './flow-producer';
+export * from './scripts';
+export * from './timer-manager';
 export * from './unrecoverable-error';
+export * from './worker';

package/dist/cjs/classes/index.js

@@ -2,18 +2,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./backoffs"), exports);
+tslib_1.__exportStar(require("./child-pool"), exports);
+tslib_1.__exportStar(require("./child-processor"), exports);
+tslib_1.__exportStar(require("./compat"), exports);
+tslib_1.__exportStar(require("./flow-producer"), exports);
 tslib_1.__exportStar(require("./job"), exports);
+tslib_1.__exportStar(require("./master"), exports);
+tslib_1.__exportStar(require("./process-utils"), exports);
 tslib_1.__exportStar(require("./queue-base"), exports);
 tslib_1.__exportStar(require("./queue-events"), exports);
 tslib_1.__exportStar(require("./queue-getters"), exports);
+tslib_1.__exportStar(require("./queue-keys"), exports);
 tslib_1.__exportStar(require("./queue-scheduler"), exports);
 tslib_1.__exportStar(require("./queue"), exports);
 tslib_1.__exportStar(require("./redis-connection"), exports);
 tslib_1.__exportStar(require("./repeat"), exports);
-tslib_1.__exportStar(require("./scripts"), exports);
-tslib_1.__exportStar(require("./worker"), exports);
-tslib_1.__exportStar(require("./child-pool"), exports);
 tslib_1.__exportStar(require("./sandbox"), exports);
-tslib_1.__exportStar(require("./flow-producer"), exports);
+tslib_1.__exportStar(require("./scripts"), exports);
+tslib_1.__exportStar(require("./timer-manager"), exports);
 tslib_1.__exportStar(require("./unrecoverable-error"), exports);
+tslib_1.__exportStar(require("./worker"), exports);
 //# sourceMappingURL=index.js.map

package/dist/cjs/classes/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/classes/index.ts"],"names":[],"mappings":";;;AAAA,qDAA2B;AAC3B,gDAAsB;AACtB,uDAA6B;AAC7B,yDAA+B;AAC/B,0DAAgC;AAChC,4DAAkC;AAClC,kDAAwB;AACxB,6DAAmC;AACnC,mDAAyB;AACzB,oDAA0B;AAC1B,mDAAyB;AACzB,uDAA6B;AAC7B,oDAA0B;AAC1B,0DAAgC;AAChC,gEAAsC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/classes/index.ts"],"names":[],"mappings":";;;AAAA,qDAA2B;AAC3B,uDAA6B;AAC7B,4DAAkC;AAClC,mDAAyB;AACzB,0DAAgC;AAChC,gDAAsB;AACtB,mDAAyB;AACzB,0DAAgC;AAChC,uDAA6B;AAC7B,yDAA+B;AAC/B,0DAAgC;AAChC,uDAA6B;AAC7B,4DAAkC;AAClC,kDAAwB;AACxB,6DAAmC;AACnC,mDAAyB;AACzB,oDAA0B;AAC1B,oDAA0B;AAC1B,0DAAgC;AAChC,gEAAsC;AACtC,mDAAyB"}

package/dist/cjs/classes/queue-getters.d.ts

@@ -1,6 +1,7 @@
 import { QueueBase } from './queue-base';
 import { Job } from './job';
 import { JobType } from '../types';
+import { Metrics } from '../interfaces';
 export declare class QueueGetters<DataType, ResultType, NameType extends string> extends QueueBase {
     getJob(jobId: string): Promise<Job<DataType, ResultType, NameType> | undefined>;
     private commandByType;
@@ -59,5 +60,20 @@ export declare class QueueGetters<DataType, ResultType, NameType extends string>
     getQueueSchedulers(): 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 poinf 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;
 }

package/dist/cjs/classes/queue-getters.js

@@ -214,6 +214,45 @@ class QueueGetters extends queue_base_1.QueueBase {
             }
         }
     }
+    /**
+     * 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 poinf of the metrics, where -1 is the
+     * oldest point to be returned.
+     *
+     * @returns - Returns an object with queue metrics.
+     */
+    async getMetrics(type, start = 0, end = -1) {
+        const client = await this.client;
+        const metricsKey = this.toKey(`metrics:${type}`);
+        const dataKey = `${metricsKey}:data`;
+        const multi = client.multi();
+        multi.hmget(metricsKey, 'count', 'prevTS', 'prevCount');
+        multi.lrange(dataKey, start, end);
+        multi.llen(dataKey);
+        const [hmget, range, len] = await multi.exec();
+        const [err, [count, prevTS, prevCount]] = hmget;
+        const [err2, data] = range;
+        const [err3, numPoints] = len;
+        if (err || err2) {
+            throw err || err2 || err3;
+        }
+        return {
+            meta: {
+                count: parseInt(count || '0', 10),
+                prevTS: parseInt(prevTS || '0', 10),
+                prevCount: parseInt(prevCount || '0', 10),
+            },
+            data,
+            count: numPoints,
+        };
+    }
     parseClientList(list, suffix = '') {
         const lines = list.split('\n');
         const clients = [];