@tramvai/module-request-limiter 1.89.1 → 1.90.4

package/lib/requestLimiter.d.ts

@@ -1,4 +1,5 @@
-import type { Request, Response, NextFunction } from 'express';
+/// <reference types="node" />
+import type { FastifyRequest, FastifyReply, HookHandlerDoneFunction } from 'fastify';
 export interface RequestLimiterOptions {
     limit?: number;
     queue?: number;
@@ -9,9 +10,9 @@ export interface RequestLimiterOptions {
     };
 }
 export interface RequestLimiterRequest {
-    req: Request;
-    res: Response;
-    next: NextFunction;
+    req: FastifyRequest;
+    res: FastifyReply;
+    next: HookHandlerDoneFunction;
 }
 export declare class RequestLimiter {
     private currentActive;
@@ -24,8 +25,12 @@ export declare class RequestLimiter {
     private maxEventLoopDelay;
     private eventLoopHistogram;
     constructor(options?: RequestLimiterOptions);
+    onResponse(): void;
     private nextTick;
     add(request: RequestLimiterRequest): void;
     private loop;
     private run;
 }
+export declare const fastifyRequestsLimiter: import("fastify").FastifyPluginAsync<{
+    requestsLimiter: RequestLimiter;
+}, import("http").Server>;

package/lib/server.es.js

@@ -1,7 +1,7 @@
 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 { WEB_FASTIFY_APP_LIMITER_TOKEN, WEB_FASTIFY_APP_TOKEN } from '@tramvai/tokens-server-private';
+import fp from 'fastify-plugin';
 import { HttpError } from '@tinkoff/errors';
 import { monitorEventLoopDelay } from 'perf_hooks';
 import { createToken } from '@tinkoff/dippy';
@@ -89,7 +89,11 @@ class RequestLimiter {
         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
+    onResponse() {
+        this.currentActive--;
+        this.loop();
+    }
+    // General idea is change limits every 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))
@@ -122,16 +126,19 @@ class RequestLimiter {
             this.run(this.queue.pop());
         }
     }
-    run({ req, res, next }) {
+    run({ 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 fastifyRequestsLimiter = fp(async (fastify, { requestsLimiter }) => {
+    fastify.addHook('onRequest', (req, res, next) => {
+        requestsLimiter.add({ req, res, next });
+    });
+    fastify.addHook('onResponse', async () => {
+        requestsLimiter.onResponse();
+    });
+});
 
 const REQUESTS_LIMITER_TOKEN = createToken('requestsLimiterToken');
 const REQUESTS_LIMITER_ACTIVATE_TOKEN = createToken('requestsLimiterActivateToken');
@@ -157,19 +164,18 @@ RequestLimiterModule = __decorate([
                 },
             }),
             provide({
-                provide: WEB_APP_LIMITER_TOKEN,
+                provide: WEB_FASTIFY_APP_LIMITER_TOKEN,
                 multi: true,
-                useFactory: ({ requestsLimiter, featureEnable }) => {
-                    return function addRequestsLimiterMiddleware(app) {
+                useFactory: ({ app, requestsLimiter, featureEnable }) => {
+                    return async () => {
                         if (featureEnable !== true) {
                             return;
                         }
-                        app.use((req, res, next) => {
-                            requestsLimiter.add({ req, res, next });
-                        });
+                        await app.register(fastifyRequestsLimiter, { requestsLimiter });
                     };
                 },
                 deps: {
+                    app: WEB_FASTIFY_APP_TOKEN,
                     requestsLimiter: REQUESTS_LIMITER_TOKEN,
                     featureEnable: { token: REQUESTS_LIMITER_ACTIVATE_TOKEN, optional: true },
                 },
@@ -178,4 +184,4 @@ RequestLimiterModule = __decorate([
     })
 ], RequestLimiterModule);
 
-export { REQUESTS_LIMITER_ACTIVATE_TOKEN, REQUESTS_LIMITER_OPTIONS_TOKEN, REQUESTS_LIMITER_TOKEN, RequestLimiter, RequestLimiterModule };
+export { REQUESTS_LIMITER_ACTIVATE_TOKEN, REQUESTS_LIMITER_OPTIONS_TOKEN, REQUESTS_LIMITER_TOKEN, RequestLimiter, RequestLimiterModule, fastifyRequestsLimiter };

package/lib/server.js

@@ -4,15 +4,15 @@ 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 tokensServerPrivate = require('@tramvai/tokens-server-private');
+var fp = require('fastify-plugin');
 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);
+var fp__default = /*#__PURE__*/_interopDefaultLegacy(fp);
 
 class DoubleLinkedList {
     constructor() {
@@ -97,7 +97,11 @@ class RequestLimiter {
         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
+    onResponse() {
+        this.currentActive--;
+        this.loop();
+    }
+    // General idea is change limits every 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))
@@ -130,16 +134,19 @@ class RequestLimiter {
             this.run(this.queue.pop());
         }
     }
-    run({ req, res, next }) {
+    run({ 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 fastifyRequestsLimiter = fp__default["default"](async (fastify, { requestsLimiter }) => {
+    fastify.addHook('onRequest', (req, res, next) => {
+        requestsLimiter.add({ req, res, next });
+    });
+    fastify.addHook('onResponse', async () => {
+        requestsLimiter.onResponse();
+    });
+});
 
 const REQUESTS_LIMITER_TOKEN = dippy.createToken('requestsLimiterToken');
 const REQUESTS_LIMITER_ACTIVATE_TOKEN = dippy.createToken('requestsLimiterActivateToken');
@@ -165,19 +172,18 @@ exports.RequestLimiterModule = tslib.__decorate([
                 },
             }),
             core.provide({
-                provide: tokensServer.WEB_APP_LIMITER_TOKEN,
+                provide: tokensServerPrivate.WEB_FASTIFY_APP_LIMITER_TOKEN,
                 multi: true,
-                useFactory: ({ requestsLimiter, featureEnable }) => {
-                    return function addRequestsLimiterMiddleware(app) {
+                useFactory: ({ app, requestsLimiter, featureEnable }) => {
+                    return async () => {
                         if (featureEnable !== true) {
                             return;
                         }
-                        app.use((req, res, next) => {
-                            requestsLimiter.add({ req, res, next });
-                        });
+                        await app.register(fastifyRequestsLimiter, { requestsLimiter });
                     };
                 },
                 deps: {
+                    app: tokensServerPrivate.WEB_FASTIFY_APP_TOKEN,
                     requestsLimiter: REQUESTS_LIMITER_TOKEN,
                     featureEnable: { token: REQUESTS_LIMITER_ACTIVATE_TOKEN, optional: true },
                 },
@@ -190,3 +196,4 @@ 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;
+exports.fastifyRequestsLimiter = fastifyRequestsLimiter;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/module-request-limiter",
-  "version": "1.89.1",
+  "version": "1.90.4",
   "description": "Enable different rendering modes for pages",
   "main": "lib/server.js",
   "module": "lib/server.es.js",
@@ -25,16 +25,14 @@
   },
   "dependencies": {
     "@tinkoff/errors": "0.2.20",
-    "on-finished": "^2.3.0"
-  },
-  "devDependencies": {
-    "@types/express": "^4.17.9"
+    "fastify-plugin": "^3.0.1"
   },
+  "devDependencies": {},
   "peerDependencies": {
     "@tinkoff/dippy": "0.7.39",
-    "@tramvai/core": "1.89.1",
-    "@tramvai/tokens-server": "1.89.1",
-    "express": "^4.17.1",
+    "@tramvai/core": "1.90.4",
+    "@tramvai/tokens-server-private": "1.90.4",
+    "fastify": "^3.0.0",
     "tslib": "^2.0.3"
   }
 }