Distributed task scheduler and rate limiter. 

Distributed task scheduler and rate limiter

sgrondin

bottleneck

             * How many jobs can be running at the same time.

            readonly maxConcurrent?: number | null;

             * How long to wait after launching a job before launching another one.

            readonly minTime?: number | null;

             * How long can the queue get? When the queue length exceeds that value, the selected `strategy` is executed to shed the load.

            readonly highWater?: number | null;

             * Which strategy to use if the queue gets longer than the high water mark.

            readonly strategy?: Bottleneck.Strategy | null;

             * The `penalty` value used by the `Bottleneck.strategy.BLOCK` strategy.

            readonly penalty?: number | null;

             * How many jobs can be executed before the limiter stops executing jobs. If `reservoir` reaches `0`, no jobs will be executed until it is no longer `0`.

            readonly reservoir?: number | null;

             * Every `reservoirRefreshInterval` milliseconds, the `reservoir` value will be automatically reset to `reservoirRefreshAmount`.

            readonly reservoirRefreshInterval?: number | null;

             * The value to reset `reservoir` to when `reservoirRefreshInterval` is in use.

            readonly reservoirRefreshAmount?: number | null;

             * The increment applied to `reservoir` when `reservoirIncreaseInterval` is in use.

            readonly reservoirIncreaseAmount?: number | null;

             * Every `reservoirIncreaseInterval` milliseconds, the `reservoir` value will be automatically incremented by `reservoirIncreaseAmount`.

            readonly reservoirIncreaseInterval?: number | null;

             * The maximum value that `reservoir` can reach when `reservoirIncreaseInterval` is in use.

            readonly reservoirIncreaseMaximum?: number | null;

             * Set to true to leave your failed jobs hanging instead of failing them.

            readonly rejectOnDrop?: boolean | null;

             * Set to true to keep track of done jobs with counts() and jobStatus(). Uses more memory.

            readonly trackDoneStatus?: boolean | null;

             * Where the limiter stores its internal state. The default (`local`) keeps the state in the limiter itself. Set it to `redis` to enable Clustering.

            readonly datastore?: string | null;

             * Override the Promise library used by Bottleneck.

             * This object is passed directly to the redis client library you've selected.

            readonly clientOptions?: any;

             * **ioredis only.** When `clusterNodes` is not null, the client will be instantiated by calling `new Redis.Cluster(clusterNodes, clientOptions)`.

             * An existing Bottleneck.RedisConnection or Bottleneck.IORedisConnection object to use.

             * If using, `datastore`, `clientOptions` and `clusterNodes` will be ignored.

             * Optional Redis/IORedis library from `require('ioredis')` or equivalent. If not, Bottleneck will attempt to require Redis/IORedis at runtime.

             * Bottleneck connection object created from `new Bottleneck.RedisConnection` or `new Bottleneck.IORedisConnection`.

            readonly connection?: Bottleneck.RedisConnection | Bottleneck.IORedisConnection | null;

             * When set to `true`, on initial startup, the limiter will wipe any existing Bottleneck state data on the Redis db.

            readonly clearDatastore?: boolean | null;

             * The Redis TTL in milliseconds for the keys created by the limiter. When `timeout` is set, the limiter's state will be automatically removed from Redis after timeout milliseconds of inactivity. Note: timeout is 300000 (5 minutes) by default when using a Group.

             readonly timeout?: number | null;

             * A priority between `0` and `9`. A job with a priority of `4` will _always_ be executed before a job with a priority of `5`.

            readonly priority?: number | null;

             * Must be an integer equal to or higher than `0`. The `weight` is what increases the number of running jobs (up to `maxConcurrent`, if using) and decreases the `reservoir` value (if using).

            readonly weight?: number | null;

             * The number milliseconds a job has to finish. Jobs that take longer than their `expiration` will be failed with a `BottleneckError`.

            readonly expiration?: number | null;

             * Optional identifier, helps with debug output.

             * When `true`, drop all the RECEIVED, QUEUED and RUNNING jobs. When `false`, allow those jobs to complete before resolving the Promise returned by this method.

            readonly dropWaitingJobs?: boolean | null;

             * The error message used to drop jobs when `dropWaitingJobs` is `true`.

            readonly dropErrorMessage?: string | null;

             * The error message used to reject a job added to the limiter after `stop()` has been called.

            readonly enqueueErrorMessage?: string | null;

        type Callback<T> = (err: any, result: T) => void;

        type ClientsList = { client?: any; subscriber?: any };

        type GroupLimiterPair = { key: string; limiter: Bottleneck };

                readonly priority: number;

                readonly expiration?: number;

        type EventInfoDropped = EventInfo & {

            readonly promise: Promise<any>;

        type EventInfoQueued = EventInfo & {

            readonly reachedHWM: boolean;

        type EventInfoRetryable = EventInfo & { readonly retryCount: number; };

             * This object is passed directly to NodeRedis' createClient() method.

             * An existing NodeRedis client to use. If using, `clientOptions` will be ignored.

             * Optional Redis library from `require('redis')` or equivalent. If not, Bottleneck will attempt to require Redis at runtime.

        type IORedisConnectionOptions = {

             * This object is passed directly to ioredis' constructor method.

             * When `clusterNodes` is not null, the client will be instantiated by calling `new Redis.Cluster(clusterNodes, clientOptions)`.

             * An existing ioredis client to use. If using, `clientOptions` and `clusterNodes` will be ignored.

             * Optional IORedis library from `require('ioredis')` or equivalent. If not, Bottleneck will attempt to require IORedis at runtime.

             * Maximum acceptable time (in milliseconds) a request can have to wait before being flushed to the `"batch"` event.

            readonly maxTime?: number | null;

             * Maximum number of requests in a batch.

            readonly maxSize?: number | null;

        class BottleneckError extends Error {

            constructor(options?: Bottleneck.RedisConnectionOptions);

             * Register an event listener.

             * @param name - The event name.

             * @param fn - The callback function.

            on(name: "error", fn: (error: any) => void): void;

             * Register an event listener for one event only.

            once(name: "error", fn: (error: any) => void): void;

             * Waits until the connection is ready and returns the raw Node_Redis clients.

            ready(): Promise<ClientsList>;

             * @param flush - Write transient data before closing.

            disconnect(flush?: boolean): Promise<void>;

            constructor(options?: Bottleneck.IORedisConnectionOptions);

             * Waits until the connection is ready and returns the raw ioredis clients.

            constructor(options?: Bottleneck.BatcherOptions);

            on(name: string, fn: Function): void;

            on(name: "batch", fn: (batch: any[]) => void): void;

            once(name: string, fn: Function): void;

            once(name: "batch", fn: (batch: any[]) => void): void;

             * Add a request to the Batcher. Batches are flushed to the "batch" event.

            add(data: any): Promise<void>;

  "homepage": "https://github.com/SGrondin/bottleneck",

    "SGrondin <github@simongrondin.name>"

  "description": "Distributed task scheduler and rate limiter",

  * This file contains the Bottleneck library (MIT), compiled to ES2017, and without Clustering support.

  * https://github.com/SGrondin/bottleneck

	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :

	typeof define === 'function' && define.amd ? define(factory) :

	var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

	function getCjsExportFromNamespace (n) {

	var load = function(received, defaults, onto = {}) {

	    onto[k] = (ref = received[k]) != null ? ref : v;

	var overwrite = function(received, defaults, onto = {}) {

	    if (typeof this.incr === "function") {

	      if (typeof this.decr === "function") {

	    if ((this._first = this._first.next) != null) {

	var version$2 = /*#__PURE__*/Object.freeze({

	var require$$2 = () => console.log('You must import the full version of Bottleneck in order to use this feature.');

	var require$$3 = () => console.log('You must import the full version of Bottleneck in order to use this feature.');

	var require$$4 = () => console.log('You must import the full version of Bottleneck in order to use this feature.');

	var Events$2, Group, IORedisConnection$1, RedisConnection$1, Scripts$1, parser$3;

	      this.deleteKey = this.deleteKey.bind(this);

	      this.limiterOptions = limiterOptions;

	      parser$3.load(this.limiterOptions, this.defaults, this);

	      this.sharedConnection = this.connection != null;

	        if (this.limiterOptions.datastore === "redis") {

	          this.connection = new RedisConnection$1(Object.assign({}, this.limiterOptions, {Events: this.Events}));

	        } else if (this.limiterOptions.datastore === "ioredis") {

	          this.connection = new IORedisConnection$1(Object.assign({}, this.limiterOptions, {Events: this.Events}));

	      return (ref = this.instances[key]) != null ? ref : (() => {

	        limiter = this.instances[key] = new this.Bottleneck(Object.assign(this.limiterOptions, {

	        this.Events.trigger("created", limiter, key);

	        deleted = (await this.connection.__runCommand__(['del', ...Scripts$1.allKeys(`${this.id}-${key}`)]));

	      return (instance != null) || deleted > 0;

	      return Object.keys(this.instances);

	      var cursor, end, found, i, k, keys, len, next, start;

	        return this.Promise.resolve(this.keys());

    "url": "https://github.com/SGrondin/bottleneck"

    "url": "https://github.com/SGrondin/bottleneck/issues"

    "ejs-cli": "github:SGrondin/ejs-cli#master",

    "rollup-plugin-node-resolve": "^3.4.0",

		@@ -80,2 +80,9 @@ declare module "bottleneck" {
		*/
		/**
		* Optional Redis/IORedis library from `require('ioredis')` or equivalent. If not, Bottleneck will attempt to require Redis/IORedis at runtime.
		*/
		readonly Redis?: any;
		/**
		* Bottleneck connection object created from `new Bottleneck.RedisConnection` or `new Bottleneck.IORedisConnection`.
		*/
		readonly connection?: Bottleneck.RedisConnection \| Bottleneck.IORedisConnection \| null;
		@@ -173,2 +180,6 @@ /**
		readonly client?: any;
		/**
		* Optional Redis library from `require('redis')` or equivalent. If not, Bottleneck will attempt to require Redis at runtime.
		*/
		readonly Redis?: any;
		};
		@@ -189,2 +200,6 @@
		readonly client?: any;
		/**
		* Optional IORedis library from `require('ioredis')` or equivalent. If not, Bottleneck will attempt to require IORedis at runtime.
		*/
		readonly Redis?: any;
		};
		@@ -191,0 +206,0 @@

		{
		"name": "bottleneck",
		"main": "bottleneck.js",
		"version": "2.19.3",
		"version": "2.19.4",
		"homepage": "https://github.com/SGrondin/bottleneck",
		@@ -6,0 +6,0 @@ "authors": [

		@@ -803,3 +803,3 @@ /**

		var version = "2.19.3";
		var version = "2.19.4";
		var version$1 = {
		@@ -806,0 +806,0 @@ version: version

		{
		"name": "bottleneck",
		"version": "2.19.3",
		"version": "2.19.4",
		"description": "Distributed task scheduler and rate limiter",
		@@ -5,0 +5,0 @@ "main": "lib/index.js",

		@@ -1,1 +0,1 @@
		{"version":"2.19.3"}
		{"version":"2.19.4"}

Improved metrics