@maioradv/nestjs-core 2.0.2 → 2.0.3

package/dist/guards/index.d.ts

@@ -1 +1,2 @@
 export * from './gql-throttler.guard';
+export * from './resource.guard';

package/dist/guards/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./gql-throttler.guard"), exports);
+__exportStar(require("./resource.guard"), exports);

package/dist/guards/resource.guard.d.ts

@@ -0,0 +1,29 @@
+import { LoggerService } from '@nestjs/common';
+export type ResourceGuardOptions = {
+    /** CPU limit in percent (per core). Optional. */
+    cpuLimit?: number;
+    /** Memory limit in MB (RSS). Optional. */
+    memoryLimitMb?: number;
+    /** Interval in ms to check CPU/memory. Default: 2000 */
+    sampleIntervalMs?: number;
+    /** How long in ms the limit must be exceeded before shutdown. Default: 10000 */
+    sustainForMs?: number;
+    /** Maximum time in ms to wait for shutdownFn before hard kill. Default: 5000 */
+    hardKillAfterMs?: number;
+    /** Optional async shutdown function. If provided, will be called before hard exit. */
+    shutdownFn?: () => Promise<void>;
+    /** Optional NestJS LoggerService to use for logging. */
+    logger?: LoggerService;
+};
+export declare class ResourceGuard {
+    private readonly opts;
+    private lastCpu;
+    private lastTime;
+    private overSince;
+    private shuttingDown;
+    constructor(opts: ResourceGuardOptions);
+    /** Start monitoring CPU and memory */
+    start(): void;
+    private check;
+    private shutdown;
+}

package/dist/guards/resource.guard.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceGuard = void 0;
+class ResourceGuard {
+    constructor(opts) {
+        this.opts = opts;
+        this.lastCpu = process.cpuUsage();
+        this.lastTime = Date.now();
+        this.overSince = null;
+        this.shuttingDown = false;
+        this.opts.sampleIntervalMs ??= 2000;
+        this.opts.sustainForMs ??= 10000;
+        this.opts.hardKillAfterMs ??= 5000;
+    }
+    /** Start monitoring CPU and memory */
+    start() {
+        if (!this.opts.cpuLimit && !this.opts.memoryLimitMb)
+            return;
+        setInterval(() => this.check(), this.opts.sampleIntervalMs).unref();
+    }
+    async check() {
+        if (this.shuttingDown)
+            return;
+        const nowTime = Date.now();
+        let over = false;
+        let currentCpuPercent = null;
+        let currentMemMb = null;
+        if (this.opts.cpuLimit) {
+            const now = process.cpuUsage(this.lastCpu);
+            const elapsedMs = nowTime - this.lastTime;
+            const cpuMs = (now.user + now.system) / 1000;
+            currentCpuPercent = (cpuMs / elapsedMs) * 100;
+            if (currentCpuPercent > this.opts.cpuLimit)
+                over = true;
+            this.lastCpu = process.cpuUsage();
+        }
+        if (this.opts.memoryLimitMb) {
+            currentMemMb = process.memoryUsage().rss / 1024 / 1024;
+            if (currentMemMb > this.opts.memoryLimitMb)
+                over = true;
+        }
+        this.lastTime = nowTime;
+        if (over) {
+            if (!this.overSince)
+                this.overSince = nowTime;
+            if (nowTime - this.overSince >= this.opts.sustainForMs) {
+                await this.shutdown(currentCpuPercent, currentMemMb);
+            }
+        }
+        else {
+            this.overSince = null;
+        }
+    }
+    async shutdown(currentCpu, currentMem) {
+        if (this.shuttingDown)
+            return;
+        this.shuttingDown = true;
+        const log = (msg) => {
+            if (this.opts.logger)
+                this.opts.logger.error(`${msg}`);
+            else
+                console.error(`${msg}`);
+        };
+        const overTimeMs = this.overSince ? Date.now() - this.overSince : 0;
+        const cpuMsg = this.opts.cpuLimit ? ` CPU: ${currentCpu?.toFixed(1)}% (${this.opts.cpuLimit}%)` : '';
+        const memMsg = this.opts.memoryLimitMb ? ` Memory: ${currentMem?.toFixed(0)}MB (${this.opts.memoryLimitMb}MB)` : '';
+        const append = [cpuMsg, memMsg, ` Exceeded for: ${overTimeMs}ms (${this.opts.sustainForMs}ms)`].filter(Boolean).join(';');
+        log(`LIMIT EXCEEDED → initiating shutdown;${append}`);
+        const hardKill = setTimeout(() => {
+            log('HARD EXIT');
+            process.exit(1);
+        }, this.opts.hardKillAfterMs);
+        try {
+            if (this.opts.shutdownFn) {
+                await this.opts.shutdownFn();
+                log('Soft shutdown completed successfully');
+            }
+        }
+        catch (e) {
+            log(`shutdownFn failed: ${e.message}`);
+        }
+        finally {
+            clearTimeout(hardKill);
+            process.exit(1);
+        }
+    }
+}
+exports.ResourceGuard = ResourceGuard;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maioradv/nestjs-core",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "description": "NestJS helpers by MaiorADV",
   "repository": "https://github.com/maioradv/nestjs-core.git",
   "author": "Maior ADV Srl",