@abyss-project/monitor 1.0.55 → 1.0.57

package/dist/middlewares/index.d.ts

@@ -1,3 +1,4 @@
 export * from './context.middleware';
 export * from './logger-endpoint.middleware';
 export * from './logger-setup.middleware';
+export * from './request-tracker.middleware';

package/dist/middlewares/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./context.middleware"), exports);
 __exportStar(require("./logger-endpoint.middleware"), exports);
 __exportStar(require("./logger-setup.middleware"), exports);
+__exportStar(require("./request-tracker.middleware"), exports);

package/dist/middlewares/request-tracker.middleware.d.ts

@@ -0,0 +1,3 @@
+import { Request, Response, NextFunction } from 'express-serve-static-core';
+import { Logger } from '../models/logger.model';
+export declare const createRequestTrackerMiddleware: (logger?: Logger) => (req: Request, res: Response, next: NextFunction) => void;

package/dist/middlewares/request-tracker.middleware.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRequestTrackerMiddleware = void 0;
+const request_tracker_utils_1 = require("../utils/request-tracker.utils");
+const graceful_shutdown_types_1 = require("../types/graceful-shutdown.types");
+const createRequestTrackerMiddleware = (logger) => {
+    return (req, res, next) => {
+        if ((0, request_tracker_utils_1.getIsShuttingDown)()) {
+            res.status(503).json({
+                errorCode: graceful_shutdown_types_1.GracefulShutdownErrorCode.SERVICE_UNAVAILABLE,
+                message: graceful_shutdown_types_1.GracefulShutdownErrorMessage[graceful_shutdown_types_1.GracefulShutdownErrorCode.SERVICE_UNAVAILABLE],
+            });
+            return;
+        }
+        (0, request_tracker_utils_1.incrementActiveRequests)();
+        let cleaned = false;
+        const cleanup = () => {
+            if (cleaned)
+                return;
+            cleaned = true;
+            (0, request_tracker_utils_1.decrementActiveRequests)();
+        };
+        res.on('finish', cleanup);
+        res.on('close', cleanup);
+        next();
+    };
+};
+exports.createRequestTrackerMiddleware = createRequestTrackerMiddleware;

package/dist/types/graceful-shutdown.types.d.ts

@@ -0,0 +1,29 @@
+import { Logger } from '../models/logger.model';
+export declare enum GracefulShutdownErrorCode {
+    SERVICE_UNAVAILABLE = "GRACEFUL_SHUTDOWN_SERVICE_UNAVAILABLE",
+    SHUTDOWN_TIMEOUT = "GRACEFUL_SHUTDOWN_TIMEOUT",
+    HTTP_SERVER_CLOSE_ERROR = "GRACEFUL_SHUTDOWN_HTTP_SERVER_CLOSE_ERROR",
+    DATABASE_CLOSE_ERROR = "GRACEFUL_SHUTDOWN_DATABASE_CLOSE_ERROR",
+    RABBITMQ_CLOSE_ERROR = "GRACEFUL_SHUTDOWN_RABBITMQ_CLOSE_ERROR",
+    REDIS_CLOSE_ERROR = "GRACEFUL_SHUTDOWN_REDIS_CLOSE_ERROR",
+    CONNECTION_CLOSE_ERROR = "GRACEFUL_SHUTDOWN_CONNECTION_CLOSE_ERROR",
+    SHUTDOWN_ERROR = "GRACEFUL_SHUTDOWN_ERROR"
+}
+export declare const GracefulShutdownErrorMessage: Record<GracefulShutdownErrorCode, string>;
+export interface ICloseableResource {
+    close: () => Promise<void> | void;
+    name?: string;
+}
+export interface IGracefulShutdownConfig {
+    logger: Logger;
+    httpServer?: {
+        close: (callback: (err?: Error) => void) => void;
+    };
+    databases?: ICloseableResource[];
+    messageQueues?: ICloseableResource[];
+    caches?: ICloseableResource[];
+    otherResources?: ICloseableResource[];
+    shutdownTimeout?: number;
+    requestsTimeout?: number;
+    checkInterval?: number;
+}

package/dist/types/graceful-shutdown.types.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GracefulShutdownErrorMessage = exports.GracefulShutdownErrorCode = void 0;
+var GracefulShutdownErrorCode;
+(function (GracefulShutdownErrorCode) {
+    GracefulShutdownErrorCode["SERVICE_UNAVAILABLE"] = "GRACEFUL_SHUTDOWN_SERVICE_UNAVAILABLE";
+    GracefulShutdownErrorCode["SHUTDOWN_TIMEOUT"] = "GRACEFUL_SHUTDOWN_TIMEOUT";
+    GracefulShutdownErrorCode["HTTP_SERVER_CLOSE_ERROR"] = "GRACEFUL_SHUTDOWN_HTTP_SERVER_CLOSE_ERROR";
+    GracefulShutdownErrorCode["DATABASE_CLOSE_ERROR"] = "GRACEFUL_SHUTDOWN_DATABASE_CLOSE_ERROR";
+    GracefulShutdownErrorCode["RABBITMQ_CLOSE_ERROR"] = "GRACEFUL_SHUTDOWN_RABBITMQ_CLOSE_ERROR";
+    GracefulShutdownErrorCode["REDIS_CLOSE_ERROR"] = "GRACEFUL_SHUTDOWN_REDIS_CLOSE_ERROR";
+    GracefulShutdownErrorCode["CONNECTION_CLOSE_ERROR"] = "GRACEFUL_SHUTDOWN_CONNECTION_CLOSE_ERROR";
+    GracefulShutdownErrorCode["SHUTDOWN_ERROR"] = "GRACEFUL_SHUTDOWN_ERROR";
+})(GracefulShutdownErrorCode || (exports.GracefulShutdownErrorCode = GracefulShutdownErrorCode = {}));
+exports.GracefulShutdownErrorMessage = {
+    [GracefulShutdownErrorCode.SERVICE_UNAVAILABLE]: 'Server is shutting down, please try again later',
+    [GracefulShutdownErrorCode.SHUTDOWN_TIMEOUT]: 'Graceful shutdown timeout, forcing exit',
+    [GracefulShutdownErrorCode.HTTP_SERVER_CLOSE_ERROR]: 'Error closing HTTP server',
+    [GracefulShutdownErrorCode.DATABASE_CLOSE_ERROR]: 'Error closing database connection',
+    [GracefulShutdownErrorCode.RABBITMQ_CLOSE_ERROR]: 'Error closing RabbitMQ connection',
+    [GracefulShutdownErrorCode.REDIS_CLOSE_ERROR]: 'Error closing Redis connections',
+    [GracefulShutdownErrorCode.CONNECTION_CLOSE_ERROR]: 'Error closing connection',
+    [GracefulShutdownErrorCode.SHUTDOWN_ERROR]: 'Error during graceful shutdown',
+};

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
 export * from './interface';
 export * from './enum';
+export * from './graceful-shutdown.types';
 export type IMonitorTimerLocals = {
     start: Date;
     startTime: [number, number];

package/dist/types/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./interface"), exports);
 __exportStar(require("./enum"), exports);
+__exportStar(require("./graceful-shutdown.types"), exports);

package/dist/types/interface/api/responses/infrastructure.admin.response.d.ts

@@ -1,7 +1,6 @@
 export interface CreateFuturePartitionsInfrastructureResponse {
     data: {
         message: string;
-        partitionsCreated: number;
         requestId: string;
     };
 }

package/dist/utils/graceful-shutdown.utils.d.ts

@@ -0,0 +1,2 @@
+import { IGracefulShutdownConfig } from '../types/graceful-shutdown.types';
+export declare const setupGracefulShutdown: (config: IGracefulShutdownConfig) => void;

package/dist/utils/graceful-shutdown.utils.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupGracefulShutdown = void 0;
+const request_tracker_utils_1 = require("../utils/request-tracker.utils");
+const graceful_shutdown_types_1 = require("../types/graceful-shutdown.types");
+const types_1 = require("../types");
+const DEFAULT_SHUTDOWN_TIMEOUT = 30000;
+const DEFAULT_REQUESTS_TIMEOUT = 25000;
+const DEFAULT_CHECK_INTERVAL = 100;
+const createGracefulShutdownLogger = (baseLogger) => {
+    const defaultPayload = {
+        context: 'GracefulShutdown',
+        scenario: types_1.LogScenario.SYSTEM_STARTUP,
+    };
+    const wrappedLogger = Object.create(baseLogger);
+    wrappedLogger.log = (message, payload, options) => baseLogger.log(message, { ...defaultPayload, ...payload }, options);
+    wrappedLogger.info = (message, payload, options) => baseLogger.info(message, { ...defaultPayload, ...payload }, options);
+    wrappedLogger.debug = (message, payload, options) => baseLogger.debug(message, { ...defaultPayload, ...payload }, options);
+    wrappedLogger.warn = (message, payload, options) => baseLogger.warn(message, { ...defaultPayload, ...payload }, options);
+    wrappedLogger.error = (message, payload, options) => baseLogger.error(message, { ...defaultPayload, ...payload }, options);
+    return wrappedLogger;
+};
+const setupGracefulShutdown = (config) => {
+    const { logger: baseLogger, httpServer, databases = [], messageQueues = [], caches = [], otherResources = [], shutdownTimeout = DEFAULT_SHUTDOWN_TIMEOUT, requestsTimeout = DEFAULT_REQUESTS_TIMEOUT, checkInterval = DEFAULT_CHECK_INTERVAL, } = config;
+    const logger = createGracefulShutdownLogger(baseLogger);
+    const gracefulShutdown = async (signal) => {
+        if ((0, request_tracker_utils_1.getIsShuttingDown)()) {
+            logger.warn(`Already shutting down, ignoring ${signal}`);
+            return;
+        }
+        (0, request_tracker_utils_1.setIsShuttingDown)(true);
+        logger.log(`Received ${signal}, starting graceful shutdown...`, {
+            data: {
+                activeRequests: (0, request_tracker_utils_1.getActiveRequestsCount)(),
+            },
+        });
+        const forceShutdownTimer = setTimeout(() => {
+            logger.error(`Graceful shutdown timeout after ${shutdownTimeout / 1000}s, forcing exit`, {
+                data: {
+                    activeRequests: (0, request_tracker_utils_1.getActiveRequestsCount)(),
+                    errorCode: graceful_shutdown_types_1.GracefulShutdownErrorCode.SHUTDOWN_TIMEOUT,
+                },
+            });
+            process.exit(1);
+        }, shutdownTimeout);
+        try {
+            const activeRequests = (0, request_tracker_utils_1.getActiveRequestsCount)();
+            if (activeRequests > 0) {
+                logger.log(`Waiting for ${activeRequests} active requests to complete...`, {
+                    data: {
+                        activeRequests,
+                        timeoutMs: requestsTimeout,
+                    },
+                });
+                try {
+                    await (0, request_tracker_utils_1.waitForActiveRequests)(requestsTimeout, checkInterval, logger);
+                }
+                catch (waitError) {
+                    logger.warn('Some requests did not complete in time, proceeding with shutdown', {
+                        data: {
+                            activeRequests: (0, request_tracker_utils_1.getActiveRequestsCount)(),
+                        },
+                    });
+                }
+            }
+            if (httpServer) {
+                await new Promise((resolve, reject) => {
+                    httpServer.close((err) => {
+                        if (err) {
+                            logger.error('Error closing HTTP server', {
+                                data: {
+                                    errorCode: graceful_shutdown_types_1.GracefulShutdownErrorCode.HTTP_SERVER_CLOSE_ERROR,
+                                },
+                            });
+                            reject(err);
+                        }
+                        else {
+                            logger.log('HTTP server closed, no longer accepting new connections');
+                            resolve();
+                        }
+                    });
+                });
+            }
+            if (messageQueues.length > 0) {
+                await Promise.allSettled(messageQueues.map(async (mq) => {
+                    try {
+                        await mq.close();
+                        logger.log(`Message queue connection closed${mq.name ? `: ${mq.name}` : ''}`);
+                    }
+                    catch (error) {
+                        logger.error(`Error closing message queue connection${mq.name ? `: ${mq.name}` : ''}`, {
+                            data: {
+                                errorCode: graceful_shutdown_types_1.GracefulShutdownErrorCode.RABBITMQ_CLOSE_ERROR,
+                                error: error instanceof Error ? error.message : String(error),
+                            },
+                        });
+                    }
+                }));
+            }
+            if (caches.length > 0) {
+                await Promise.allSettled(caches.map(async (cache) => {
+                    try {
+                        await cache.close();
+                        logger.log(`Cache connection closed${cache.name ? `: ${cache.name}` : ''}`);
+                    }
+                    catch (error) {
+                        logger.error(`Error closing cache connection${cache.name ? `: ${cache.name}` : ''}`, {
+                            data: {
+                                errorCode: graceful_shutdown_types_1.GracefulShutdownErrorCode.REDIS_CLOSE_ERROR,
+                                error: error instanceof Error ? error.message : String(error),
+                            },
+                        });
+                    }
+                }));
+            }
+            if (databases.length > 0) {
+                await Promise.allSettled(databases.map(async (db) => {
+                    try {
+                        await db.close();
+                        logger.log(`Database connection closed${db.name ? `: ${db.name}` : ''}`);
+                    }
+                    catch (error) {
+                        logger.error(`Error closing database connection${db.name ? `: ${db.name}` : ''}`, {
+                            data: {
+                                errorCode: graceful_shutdown_types_1.GracefulShutdownErrorCode.DATABASE_CLOSE_ERROR,
+                                error: error instanceof Error ? error.message : String(error),
+                            },
+                        });
+                    }
+                }));
+            }
+            if (otherResources.length > 0) {
+                await Promise.allSettled(otherResources.map(async (resource) => {
+                    try {
+                        await resource.close();
+                        logger.log(`Resource closed${resource.name ? `: ${resource.name}` : ''}`);
+                    }
+                    catch (error) {
+                        logger.error(`Error closing resource${resource.name ? `: ${resource.name}` : ''}`, {
+                            data: {
+                                errorCode: graceful_shutdown_types_1.GracefulShutdownErrorCode.CONNECTION_CLOSE_ERROR,
+                                error: error instanceof Error ? error.message : String(error),
+                            },
+                        });
+                    }
+                }));
+            }
+            logger.log('Graceful shutdown completed successfully');
+            clearTimeout(forceShutdownTimer);
+            process.exit(0);
+        }
+        catch (shutdownError) {
+            logger.error('Error during graceful shutdown', {
+                data: {
+                    errorCode: graceful_shutdown_types_1.GracefulShutdownErrorCode.SHUTDOWN_ERROR,
+                    error: shutdownError instanceof Error ? shutdownError.message : String(shutdownError),
+                },
+            });
+            clearTimeout(forceShutdownTimer);
+            process.exit(1);
+        }
+    };
+    process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+    process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+    process.on('uncaughtException', (err) => {
+        logger.error('Uncaught Exception', {
+            data: {
+                error: err.message,
+                stack: err.stack,
+            },
+        });
+        gracefulShutdown('uncaughtException');
+    });
+    process.on('unhandledRejection', (reason) => {
+        logger.error('Unhandled Rejection', {
+            data: {
+                reason: reason instanceof Error ? reason.message : String(reason),
+            },
+        });
+        gracefulShutdown('unhandledRejection');
+    });
+    logger.log('Graceful shutdown handlers registered');
+};
+exports.setupGracefulShutdown = setupGracefulShutdown;

package/dist/utils/index.d.ts

@@ -3,3 +3,5 @@ export * from './discord-webhook-log-formatter.utils';
 export * from './json.utils';
 export * from './alert.utils';
 export * from './non-blocking-promise.utils';
+export * from './request-tracker.utils';
+export * from './graceful-shutdown.utils';

package/dist/utils/index.js

@@ -19,3 +19,5 @@ __exportStar(require("./discord-webhook-log-formatter.utils"), exports);
 __exportStar(require("./json.utils"), exports);
 __exportStar(require("./alert.utils"), exports);
 __exportStar(require("./non-blocking-promise.utils"), exports);
+__exportStar(require("./request-tracker.utils"), exports);
+__exportStar(require("./graceful-shutdown.utils"), exports);

package/dist/utils/request-tracker.utils.d.ts

@@ -0,0 +1,7 @@
+import { Logger } from '../models/logger.model';
+export declare const getActiveRequestsCount: () => number;
+export declare const getIsShuttingDown: () => boolean;
+export declare const setIsShuttingDown: (value: boolean) => void;
+export declare const incrementActiveRequests: () => void;
+export declare const decrementActiveRequests: () => void;
+export declare const waitForActiveRequests: (timeout?: number, checkInterval?: number, logger?: Logger) => Promise<void>;

package/dist/utils/request-tracker.utils.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForActiveRequests = exports.decrementActiveRequests = exports.incrementActiveRequests = exports.setIsShuttingDown = exports.getIsShuttingDown = exports.getActiveRequestsCount = void 0;
+const graceful_shutdown_types_1 = require("../types/graceful-shutdown.types");
+let activeRequests = 0;
+let isShuttingDown = false;
+const getActiveRequestsCount = () => activeRequests;
+exports.getActiveRequestsCount = getActiveRequestsCount;
+const getIsShuttingDown = () => isShuttingDown;
+exports.getIsShuttingDown = getIsShuttingDown;
+const setIsShuttingDown = (value) => {
+    isShuttingDown = value;
+};
+exports.setIsShuttingDown = setIsShuttingDown;
+const incrementActiveRequests = () => {
+    activeRequests++;
+};
+exports.incrementActiveRequests = incrementActiveRequests;
+const decrementActiveRequests = () => {
+    activeRequests--;
+};
+exports.decrementActiveRequests = decrementActiveRequests;
+const waitForActiveRequests = async (timeout = 30000, checkInterval = 100, logger) => {
+    const startTime = Date.now();
+    return new Promise((resolve, reject) => {
+        const check = () => {
+            if (activeRequests === 0) {
+                logger === null || logger === void 0 ? void 0 : logger.log('All active requests completed');
+                resolve();
+                return;
+            }
+            if (Date.now() - startTime >= timeout) {
+                const errorMessage = `Timeout waiting for ${activeRequests} active requests to complete`;
+                logger === null || logger === void 0 ? void 0 : logger.warn(errorMessage, {
+                    data: {
+                        activeRequests,
+                        timeoutMs: timeout,
+                        errorCode: graceful_shutdown_types_1.GracefulShutdownErrorCode.SHUTDOWN_TIMEOUT,
+                    },
+                });
+                reject(new Error(errorMessage));
+                return;
+            }
+            logger === null || logger === void 0 ? void 0 : logger.debug(`Waiting for ${activeRequests} active requests to complete...`, {
+                data: {
+                    activeRequests,
+                    elapsedMs: Date.now() - startTime,
+                },
+            });
+            setTimeout(check, checkInterval);
+        };
+        check();
+    });
+};
+exports.waitForActiveRequests = waitForActiveRequests;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abyss-project/monitor",
-  "version": "1.0.55",
+  "version": "1.0.57",
   "description": "Core package to interact with Abyss-Monitor",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",