@tramvai/module-request-limiter 1.75.0

package/README.md

@@ -0,0 +1,70 @@
+# @tramvai/module-request-limiter
+
+This module provides a request limiter, designed to dynamically limit the number of requests handled concurrently by the application.
+Request limiter monitors the application server health through event loop lag checks. 
+
+## Installation
+
+You need to install `@tramvai/module-request-limiter`
+
+```bash npm2yarn
+yarn add @tramvai/module-request-limiter
+```
+
+And connect in the project
+
+```tsx
+import { createApp } from '@tramvai/core';
+import { RequestLimiterModule } from '@tramvai/module-request-limiter';
+
+createApp({
+  name: 'tincoin',
+  modules: [ RequestLimiterModule ],
+});
+```
+
+## Usage
+
+### Activation
+
+To activate the limiter, use token `REQUESTS_LIMITER_ACTIVATE_TOKEN` with `true` value:
+
+```ts
+import { REQUESTS_LIMITER_ACTIVATE_TOKEN } from '@tramvai/module-request-limiter';
+
+const provider = {
+  provide: REQUESTS_LIMITER_ACTIVATE_TOKEN,
+  useValue: true,
+};
+```
+
+### Configuration
+
+You can pass options to request limiter by `REQUESTS_LIMITER_OPTIONS_TOKEN` token:
+
+```ts
+import { REQUESTS_LIMITER_OPTIONS_TOKEN } from '@tramvai/module-request-limiter';
+
+const provider = {
+  provide: REQUESTS_LIMITER_OPTIONS_TOKEN,
+  // default options
+  useValue: {
+    limit: 10,
+    queue: 100,
+    maxEventLoopDelay: 150,
+    error: { httpStatus: 429, message: 'Too Many Requests' },
+  },
+};
+```
+
+## Explanation
+
+After the server starts, request limiter can handle `options.limit` parallel connections.
+Requests over this limit will fall in queue, the size of which limited by `options.queue`.
+Other connections that exceed the size of the queue will be terminated with an error `options.error`.
+
+Requests from queue will be processed from the end of the queue. 
+
+Every second limiter checking the current event loop lag.
+If current lag exceed the `options.maxEventLoopDelay`, limit number of parallel connections will be decremented.
+Otherwise, this limit will be incremented.

package/lib/browser.d.ts

@@ -0,0 +1,2 @@
+export declare class RequestLimiterModule {
+}

package/lib/browser.js

@@ -0,0 +1,12 @@
+import { __decorate } from 'tslib';
+import { Module } from '@tramvai/core';
+
+let RequestLimiterModule = class RequestLimiterModule {
+};
+RequestLimiterModule = __decorate([
+    Module({
+        providers: [],
+    })
+], RequestLimiterModule);
+
+export { RequestLimiterModule };

package/lib/requestLimiter.d.ts

@@ -0,0 +1,31 @@
+import type { Request, Response, NextFunction } from 'express';
+export interface RequestLimiterOptions {
+    limit?: number;
+    queue?: number;
+    maxEventLoopDelay?: number;
+    error?: {
+        httpStatus: number;
+        message: string;
+    };
+}
+export interface RequestLimiterRequest {
+    req: Request;
+    res: Response;
+    next: NextFunction;
+}
+export declare class RequestLimiter {
+    private currentActive;
+    private eventLoopDelay;
+    private queue;
+    private activeRequestLimit;
+    private queueLimit;
+    private error;
+    private minimalActiveRequestLimit;
+    private maxEventLoopDelay;
+    private eventLoopHistogram;
+    constructor(options?: RequestLimiterOptions);
+    private nextTick;
+    add(request: RequestLimiterRequest): void;
+    private loop;
+    private run;
+}

package/lib/server.d.ts

@@ -0,0 +1,4 @@
+export * from './requestLimiter';
+export * from './tokens';
+export declare class RequestLimiterModule {
+}

package/lib/server.es.js

@@ -0,0 +1,181 @@
+import { __decorate } from 'tslib';
+import { Module, provide, Scope } from '@tramvai/core';
+import { WEB_APP_LIMITER_TOKEN } from '@tramvai/tokens-server';
+import onFinished from 'on-finished';
+import { HttpError } from '@tinkoff/errors';
+import { monitorEventLoopDelay } from 'perf_hooks';
+import { createToken } from '@tinkoff/dippy';
+
+class DoubleLinkedList {
+    constructor() {
+        this.length = 0;
+        this.start = null;
+        this.end = null;
+    }
+    push(value) {
+        const newNode = {
+            value,
+            next: null,
+            prev: null,
+        };
+        this.length++;
+        if (this.start === null) {
+            this.start = newNode;
+            this.end = newNode;
+            return;
+        }
+        const currentEnd = this.end;
+        this.end = newNode;
+        this.end.prev = currentEnd;
+        currentEnd.next = this.end;
+    }
+    pop() {
+        if (this.end === null) {
+            return null;
+        }
+        this.length--;
+        // if equal we have only 1 node, so we just remove start
+        if (this.end === this.start) {
+            this.start = null;
+        }
+        const { value } = this.end;
+        this.end = this.end.prev;
+        if (this.end) {
+            this.end.next = null;
+        }
+        return value;
+    }
+    shift() {
+        if (this.start === null) {
+            return null;
+        }
+        this.length--;
+        // if equal we have only 1 node, so we just remove end
+        if (this.end === this.start) {
+            this.end = null;
+        }
+        const { value } = this.start;
+        this.start = this.start.next;
+        if (this.start) {
+            this.start.prev = null;
+        }
+        return value;
+    }
+    size() {
+        return this.length;
+    }
+}
+
+const DEFAULT_OPTIONS = {
+    limit: 10,
+    queue: 100,
+    maxEventLoopDelay: 150,
+    error: { httpStatus: 429, message: 'Too Many Requests' },
+};
+const resolution = 10;
+class RequestLimiter {
+    constructor(options = DEFAULT_OPTIONS) {
+        this.currentActive = 0;
+        this.eventLoopDelay = 0;
+        this.queue = new DoubleLinkedList();
+        const { limit = DEFAULT_OPTIONS.limit, queue = DEFAULT_OPTIONS.queue, maxEventLoopDelay = DEFAULT_OPTIONS.maxEventLoopDelay, error = DEFAULT_OPTIONS.error, } = options;
+        this.activeRequestLimit = limit;
+        this.minimalActiveRequestLimit = Math.floor(limit / 2);
+        this.queueLimit = queue;
+        this.error = error;
+        this.maxEventLoopDelay = maxEventLoopDelay;
+        this.eventLoopHistogram = monitorEventLoopDelay({ resolution });
+        this.eventLoopHistogram.enable();
+        const timer = setInterval(() => this.nextTick(), 1000);
+        timer.unref();
+    }
+    // General idea is change limits ever second. Because if DDOS was happened we need some time to get problem with event loop. And better if we slowly adapt
+    nextTick() {
+        this.eventLoopDelay = Math.max(0, this.eventLoopHistogram.mean / 1e6 - resolution);
+        if (Number.isNaN(this.eventLoopDelay))
+            this.eventLoopDelay = Infinity;
+        this.eventLoopHistogram.reset();
+        if (this.currentActive >= this.activeRequestLimit &&
+            this.activeRequestLimit > this.minimalActiveRequestLimit) {
+            if (this.eventLoopDelay <= this.maxEventLoopDelay) {
+                this.activeRequestLimit++;
+            }
+            else {
+                this.activeRequestLimit--;
+            }
+        }
+    }
+    add(request) {
+        if (this.currentActive < this.activeRequestLimit) {
+            this.run(request);
+            return;
+        }
+        if (this.queue.length >= this.queueLimit) {
+            const lastNode = this.queue.shift();
+            lastNode.next(new HttpError(this.error));
+        }
+        this.queue.push(request);
+    }
+    loop() {
+        while (this.queue.length > 0 && this.currentActive < this.activeRequestLimit) {
+            // better if we start with new requests. Because more opportunity to answer before client cancel request
+            this.run(this.queue.pop());
+        }
+    }
+    run({ req, res, next }) {
+        this.currentActive++;
+        // onFinished doesn't work OK in DEV mode. Just stuck with high load without any reasons
+        onFinished(res, () => {
+            this.currentActive--;
+            this.loop();
+        });
+        next();
+    }
+}
+
+const REQUESTS_LIMITER_TOKEN = createToken('requestsLimiterToken');
+const REQUESTS_LIMITER_ACTIVATE_TOKEN = createToken('requestsLimiterActivateToken');
+const REQUESTS_LIMITER_OPTIONS_TOKEN = createToken('requestsLimiterOptionsToken');
+
+let RequestLimiterModule = class RequestLimiterModule {
+};
+RequestLimiterModule = __decorate([
+    Module({
+        providers: [
+            provide({
+                provide: REQUESTS_LIMITER_TOKEN,
+                scope: Scope.SINGLETON,
+                useFactory: ({ options, featureEnable }) => {
+                    if (featureEnable !== true) {
+                        return;
+                    }
+                    return new RequestLimiter(options);
+                },
+                deps: {
+                    options: { token: REQUESTS_LIMITER_OPTIONS_TOKEN, optional: true },
+                    featureEnable: { token: REQUESTS_LIMITER_ACTIVATE_TOKEN, optional: true },
+                },
+            }),
+            provide({
+                provide: WEB_APP_LIMITER_TOKEN,
+                multi: true,
+                useFactory: ({ requestsLimiter, featureEnable }) => {
+                    return function addRequestsLimiterMiddleware(app) {
+                        if (featureEnable !== true) {
+                            return;
+                        }
+                        app.use((req, res, next) => {
+                            requestsLimiter.add({ req, res, next });
+                        });
+                    };
+                },
+                deps: {
+                    requestsLimiter: REQUESTS_LIMITER_TOKEN,
+                    featureEnable: { token: REQUESTS_LIMITER_ACTIVATE_TOKEN, optional: true },
+                },
+            }),
+        ],
+    })
+], RequestLimiterModule);
+
+export { REQUESTS_LIMITER_ACTIVATE_TOKEN, REQUESTS_LIMITER_OPTIONS_TOKEN, REQUESTS_LIMITER_TOKEN, RequestLimiter, RequestLimiterModule };

package/lib/server.js

@@ -0,0 +1,192 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var core = require('@tramvai/core');
+var tokensServer = require('@tramvai/tokens-server');
+var onFinished = require('on-finished');
+var errors = require('@tinkoff/errors');
+var perf_hooks = require('perf_hooks');
+var dippy = require('@tinkoff/dippy');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var onFinished__default = /*#__PURE__*/_interopDefaultLegacy(onFinished);
+
+class DoubleLinkedList {
+    constructor() {
+        this.length = 0;
+        this.start = null;
+        this.end = null;
+    }
+    push(value) {
+        const newNode = {
+            value,
+            next: null,
+            prev: null,
+        };
+        this.length++;
+        if (this.start === null) {
+            this.start = newNode;
+            this.end = newNode;
+            return;
+        }
+        const currentEnd = this.end;
+        this.end = newNode;
+        this.end.prev = currentEnd;
+        currentEnd.next = this.end;
+    }
+    pop() {
+        if (this.end === null) {
+            return null;
+        }
+        this.length--;
+        // if equal we have only 1 node, so we just remove start
+        if (this.end === this.start) {
+            this.start = null;
+        }
+        const { value } = this.end;
+        this.end = this.end.prev;
+        if (this.end) {
+            this.end.next = null;
+        }
+        return value;
+    }
+    shift() {
+        if (this.start === null) {
+            return null;
+        }
+        this.length--;
+        // if equal we have only 1 node, so we just remove end
+        if (this.end === this.start) {
+            this.end = null;
+        }
+        const { value } = this.start;
+        this.start = this.start.next;
+        if (this.start) {
+            this.start.prev = null;
+        }
+        return value;
+    }
+    size() {
+        return this.length;
+    }
+}
+
+const DEFAULT_OPTIONS = {
+    limit: 10,
+    queue: 100,
+    maxEventLoopDelay: 150,
+    error: { httpStatus: 429, message: 'Too Many Requests' },
+};
+const resolution = 10;
+class RequestLimiter {
+    constructor(options = DEFAULT_OPTIONS) {
+        this.currentActive = 0;
+        this.eventLoopDelay = 0;
+        this.queue = new DoubleLinkedList();
+        const { limit = DEFAULT_OPTIONS.limit, queue = DEFAULT_OPTIONS.queue, maxEventLoopDelay = DEFAULT_OPTIONS.maxEventLoopDelay, error = DEFAULT_OPTIONS.error, } = options;
+        this.activeRequestLimit = limit;
+        this.minimalActiveRequestLimit = Math.floor(limit / 2);
+        this.queueLimit = queue;
+        this.error = error;
+        this.maxEventLoopDelay = maxEventLoopDelay;
+        this.eventLoopHistogram = perf_hooks.monitorEventLoopDelay({ resolution });
+        this.eventLoopHistogram.enable();
+        const timer = setInterval(() => this.nextTick(), 1000);
+        timer.unref();
+    }
+    // General idea is change limits ever second. Because if DDOS was happened we need some time to get problem with event loop. And better if we slowly adapt
+    nextTick() {
+        this.eventLoopDelay = Math.max(0, this.eventLoopHistogram.mean / 1e6 - resolution);
+        if (Number.isNaN(this.eventLoopDelay))
+            this.eventLoopDelay = Infinity;
+        this.eventLoopHistogram.reset();
+        if (this.currentActive >= this.activeRequestLimit &&
+            this.activeRequestLimit > this.minimalActiveRequestLimit) {
+            if (this.eventLoopDelay <= this.maxEventLoopDelay) {
+                this.activeRequestLimit++;
+            }
+            else {
+                this.activeRequestLimit--;
+            }
+        }
+    }
+    add(request) {
+        if (this.currentActive < this.activeRequestLimit) {
+            this.run(request);
+            return;
+        }
+        if (this.queue.length >= this.queueLimit) {
+            const lastNode = this.queue.shift();
+            lastNode.next(new errors.HttpError(this.error));
+        }
+        this.queue.push(request);
+    }
+    loop() {
+        while (this.queue.length > 0 && this.currentActive < this.activeRequestLimit) {
+            // better if we start with new requests. Because more opportunity to answer before client cancel request
+            this.run(this.queue.pop());
+        }
+    }
+    run({ req, res, next }) {
+        this.currentActive++;
+        // onFinished doesn't work OK in DEV mode. Just stuck with high load without any reasons
+        onFinished__default["default"](res, () => {
+            this.currentActive--;
+            this.loop();
+        });
+        next();
+    }
+}
+
+const REQUESTS_LIMITER_TOKEN = dippy.createToken('requestsLimiterToken');
+const REQUESTS_LIMITER_ACTIVATE_TOKEN = dippy.createToken('requestsLimiterActivateToken');
+const REQUESTS_LIMITER_OPTIONS_TOKEN = dippy.createToken('requestsLimiterOptionsToken');
+
+exports.RequestLimiterModule = class RequestLimiterModule {
+};
+exports.RequestLimiterModule = tslib.__decorate([
+    core.Module({
+        providers: [
+            core.provide({
+                provide: REQUESTS_LIMITER_TOKEN,
+                scope: core.Scope.SINGLETON,
+                useFactory: ({ options, featureEnable }) => {
+                    if (featureEnable !== true) {
+                        return;
+                    }
+                    return new RequestLimiter(options);
+                },
+                deps: {
+                    options: { token: REQUESTS_LIMITER_OPTIONS_TOKEN, optional: true },
+                    featureEnable: { token: REQUESTS_LIMITER_ACTIVATE_TOKEN, optional: true },
+                },
+            }),
+            core.provide({
+                provide: tokensServer.WEB_APP_LIMITER_TOKEN,
+                multi: true,
+                useFactory: ({ requestsLimiter, featureEnable }) => {
+                    return function addRequestsLimiterMiddleware(app) {
+                        if (featureEnable !== true) {
+                            return;
+                        }
+                        app.use((req, res, next) => {
+                            requestsLimiter.add({ req, res, next });
+                        });
+                    };
+                },
+                deps: {
+                    requestsLimiter: REQUESTS_LIMITER_TOKEN,
+                    featureEnable: { token: REQUESTS_LIMITER_ACTIVATE_TOKEN, optional: true },
+                },
+            }),
+        ],
+    })
+], exports.RequestLimiterModule);
+
+exports.REQUESTS_LIMITER_ACTIVATE_TOKEN = REQUESTS_LIMITER_ACTIVATE_TOKEN;
+exports.REQUESTS_LIMITER_OPTIONS_TOKEN = REQUESTS_LIMITER_OPTIONS_TOKEN;
+exports.REQUESTS_LIMITER_TOKEN = REQUESTS_LIMITER_TOKEN;
+exports.RequestLimiter = RequestLimiter;

package/lib/tokens.d.ts

@@ -0,0 +1,4 @@
+import type { RequestLimiter, RequestLimiterOptions } from './requestLimiter';
+export declare const REQUESTS_LIMITER_TOKEN: RequestLimiter;
+export declare const REQUESTS_LIMITER_ACTIVATE_TOKEN: boolean;
+export declare const REQUESTS_LIMITER_OPTIONS_TOKEN: RequestLimiterOptions;

package/lib/utils/doubleLinkedList.d.ts

@@ -0,0 +1,15 @@
+interface ListNode<Value> {
+    next: ListNode<Value>;
+    prev: ListNode<Value>;
+    value: Value;
+}
+export declare class DoubleLinkedList<Value> {
+    length: number;
+    start: null | ListNode<Value>;
+    end: null | ListNode<Value>;
+    push(value: Value): void;
+    pop(): Value;
+    shift(): Value;
+    size(): number;
+}
+export {};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@tramvai/module-request-limiter",
+  "version": "1.75.0",
+  "description": "Enable different rendering modes for pages",
+  "main": "lib/server.js",
+  "module": "lib/server.es.js",
+  "browser": "lib/browser.js",
+  "typings": "lib/server.d.ts",
+  "files": [
+    "lib"
+  ],
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:Tinkoff/tramvai.git"
+  },
+  "license": "Apache-2.0",
+  "scripts": {
+    "build": "tramvai-build --for-publish",
+    "watch": "tsc -w",
+    "build-for-publish": "true"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@tinkoff/errors": "0.2.18",
+    "on-finished": "^2.3.0"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.9"
+  },
+  "peerDependencies": {
+    "@tinkoff/dippy": "0.7.38",
+    "@tramvai/core": "1.75.0",
+    "@tramvai/tokens-server": "1.75.0",
+    "express": "^4.17.1",
+    "tslib": "^2.0.3"
+  }
+}