@yolo-croket-dev/core 1.7.22 → 1.7.24

package/interceptors/rpc.interceptor.js

@@ -365,20 +365,33 @@ let RPCInterceptor = class RPCInterceptor {
         // eslint-disable-next-line consistent-return
         (0, operators_1.catchError)(async (err) => {
             // timeout 에러 처리
-            msaLogger.error('Timeout occurred, requeuing message', { traceId: execInterceptor.traceId }, {
-                error: {
-                    message: err.message,
-                    stack: err.stack,
-                    name: err.name,
-                    response: err.response,
-                },
-            });
             const isTimeoutError = err instanceof Error && err.name === 'TimeoutError';
-            if (isTimeoutError && !execInterceptor.isMessageAck) {
-                channel.nack(message, false, true);
-                execInterceptor.isMessageAck = true;
-                message.properties.replyTo = undefined; /** replyTo가 존재하면 sendToQueue가 호출되므로, 삭제해주기 */
-                msaLogger.debug('TimeoutError occurred, message requeued called', { traceId: execInterceptor.traceId });
+            if (isTimeoutError) {
+                msaLogger.error('[타임 아웃] 메시지 재전송 처리', { traceId: execInterceptor.traceId }, {
+                    error: {
+                        message: err.message,
+                        stack: err.stack,
+                        name: err.name,
+                        response: err.response,
+                    },
+                });
+                if (!execInterceptor.isMessageAck) {
+                    channel.nack(message, false, true);
+                    execInterceptor.isMessageAck = true;
+                    message.properties.replyTo = undefined; /** replyTo가 존재하면 sendToQueue가 호출되므로, 삭제해주기 */
+                    msaLogger.debug('TimeoutError occurred, message requeued called', { traceId: execInterceptor.traceId });
+                    return new rxjs_1.Observable();
+                }
+            }
+            else {
+                msaLogger.error('에러 응답 전송 처리', { traceId: execInterceptor.traceId }, {
+                    error: {
+                        message: err.message,
+                        stack: err.stack,
+                        name: err.name,
+                        response: err.response,
+                    },
+                });
                 return new rxjs_1.Observable();
             }
         }), (0, operators_1.finalize)(() => {

package/modules/graceful-shutdown/graceful-shutdown.module.d.ts

@@ -1,2 +1,7 @@
-export declare class GracefulShutdownModule {
+import { OnModuleDestroy } from '@nestjs/common';
+import { GracefulShutdownService } from './graceful-shutdown.service';
+export declare class GracefulShutdownModule implements OnModuleDestroy {
+    private readonly gracefulShutdownService;
+    constructor(gracefulShutdownService: GracefulShutdownService);
+    onModuleDestroy(): Promise<void>;
 }

package/modules/graceful-shutdown/graceful-shutdown.module.js

@@ -5,11 +5,25 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GracefulShutdownModule = void 0;
 const common_1 = require("@nestjs/common");
 const graceful_shutdown_service_1 = require("./graceful-shutdown.service");
 let GracefulShutdownModule = class GracefulShutdownModule {
+    constructor(gracefulShutdownService) {
+        this.gracefulShutdownService = gracefulShutdownService;
+    }
+    async onModuleDestroy() {
+        // GracefulShutdownService가 완료될 때까지 대기
+        while (this.gracefulShutdownService.getActiveInterceptorsCount() > 0) {
+            await new Promise(resolve => {
+                setTimeout(() => resolve(), 100);
+            });
+        }
+    }
 };
 exports.GracefulShutdownModule = GracefulShutdownModule;
 exports.GracefulShutdownModule = GracefulShutdownModule = __decorate([
@@ -17,5 +31,6 @@ exports.GracefulShutdownModule = GracefulShutdownModule = __decorate([
     (0, common_1.Module)({
         providers: [graceful_shutdown_service_1.GracefulShutdownService],
         exports: [graceful_shutdown_service_1.GracefulShutdownService],
-    })
+    }),
+    __metadata("design:paramtypes", [graceful_shutdown_service_1.GracefulShutdownService])
 ], GracefulShutdownModule);

package/modules/graceful-shutdown/graceful-shutdown.service.d.ts

@@ -9,10 +9,15 @@ export declare class GracefulShutdownService implements OnApplicationShutdown, O
     private activeInterceptors;
     isApplicationExit: boolean;
     private readonly HEALTHY_FILE_PATH;
+    private shutdownSignal?;
+    private isShutdownInProgress;
     onApplicationBootstrap(): void;
     pushActiveInterceptors(execInterceptor: GracefulExecInterceptor): void;
     popActiveInterceptors(execInterceptor: GracefulExecInterceptor): void;
+    getActiveInterceptorsCount(): number;
+    getShutdownStatus(): boolean;
     onApplicationShutdown(signal?: string): Promise<void>;
     onModuleDestroy(): Promise<void>;
+    private waitForActiveInterceptors;
 }
 export {};

package/modules/graceful-shutdown/graceful-shutdown.service.js

@@ -39,6 +39,7 @@ let GracefulShutdownService = class GracefulShutdownService {
         this.activeInterceptors = [];
         this.isApplicationExit = false;
         this.HEALTHY_FILE_PATH = '/tmp/healthy';
+        this.isShutdownInProgress = false;
     }
     onApplicationBootstrap() {
         this.activeInterceptors = [];
@@ -54,6 +55,7 @@ let GracefulShutdownService = class GracefulShutdownService {
         // Health check 용 파일 생성
         (0, fs_1.writeFileSync)(this.HEALTHY_FILE_PATH, (new Date().toISOString()));
         const isHealthyFileExist = (0, fs_1.existsSync)(this.HEALTHY_FILE_PATH);
+        // eslint-disable-next-line max-len
         msaLogger.debug(`GracefulShutdownService.onApplicationBootstrap isExecLocal=${this.isExecLocal}`, { traceId: 'ON_APPLICATION_BOOTSTRAP' }, { isHealthyFileExist });
     }
     pushActiveInterceptors(execInterceptor) {
@@ -63,35 +65,76 @@ let GracefulShutdownService = class GracefulShutdownService {
         // eslint-disable-next-line max-len
         this.activeInterceptors = this.activeInterceptors.filter((item) => !(item.method === execInterceptor.method && item.traceId === execInterceptor.traceId && item.correlationId === execInterceptor.correlationId));
     }
+    getActiveInterceptorsCount() {
+        return this.activeInterceptors.length;
+    }
+    getShutdownStatus() {
+        return this.isShutdownInProgress;
+    }
     async onApplicationShutdown(signal) {
+        if (this.isShutdownInProgress) {
+            msaLogger.debug(`GracefulShutdownService.onApplicationShutdown already in progress, signal=${signal}`, { traceId: 'ON_APPLICATION_SHUTDOWN' });
+            return;
+        }
+        this.isShutdownInProgress = true;
+        this.shutdownSignal = signal;
+        this.isApplicationExit = true;
         msaLogger.debug(`GracefulShutdownService.onApplicationShutdown signal=${signal}`, { traceId: 'ON_APPLICATION_SHUTDOWN' });
+        // onApplicationShutdown에서 모든 activeInterceptors 완료를 기다림
+        // 이렇게 하면 onModuleDestroy가 호출되기 전에 모든 이벤트가 처리됨
+        await this.waitForActiveInterceptors();
+        msaLogger.info('GracefulShutdownService.onApplicationShutdown: all interceptors finished, shutting down', { traceId: 'ON_APPLICATION_SHUTDOWN' });
+        // 모든 이벤트 처리 완료 후 종료
         process.exit(0);
     }
     async onModuleDestroy() {
-        this.isApplicationExit = true;
         msaLogger.debug('GracefulShutdownService.onModuleDestroy', { traceId: 'ON_MODULE_DESTROY' });
+        // onModuleDestroy에서는 단순히 플래그만 설정
+        // 실제 대기는 onApplicationShutdown에서 처리됨
+        this.isApplicationExit = true;
+    }
+    async waitForActiveInterceptors() {
         if (this.isExecLocal) {
-            msaLogger.debug('GracefulShutdownService.onModuleDestroy isExecLocal=true, process exit', { traceId: 'ON_MODULE_DESTROY' });
+            msaLogger.debug('GracefulShutdownService.waitForActiveInterceptors isExecLocal=true', { traceId: 'WAIT_FOR_INTERCEPTORS' });
             return;
         }
         // eslint-disable-next-line max-len
-        msaLogger.debug('GracefulShutdownService.onModuleDestroy activeInterceptors', { traceId: 'ON_MODULE_DESTROY' }, { activeInterceptors: this.activeInterceptors });
+        msaLogger.debug('GracefulShutdownService.waitForActiveInterceptors activeInterceptors', { traceId: 'WAIT_FOR_INTERCEPTORS' }, { activeInterceptors: this.activeInterceptors });
         let prevExecInterceptorCount = 0;
         let count = 0;
-        while (this.activeInterceptors.length) {
+        const maxWaitTime = 1000 * 60 * 10; // 최대 10분 대기
+        const startTime = Date.now();
+        while (this.activeInterceptors.length > 0) {
             count += 1;
+            // 최대 대기 시간 체크
+            if (Date.now() - startTime > maxWaitTime) {
+                // eslint-disable-next-line max-len
+                msaLogger.warn('GracefulShutdownService.waitForActiveInterceptors: max wait time exceeded, forcing shutdown', { traceId: 'WAIT_FOR_INTERCEPTORS' }, {
+                    activeInterceptors: this.activeInterceptors,
+                    count,
+                    maxWaitTime,
+                });
+                break;
+            }
             if ((prevExecInterceptorCount !== this.activeInterceptors.length) || (count % 100 === 0)) {
                 prevExecInterceptorCount = this.activeInterceptors.length;
                 // eslint-disable-next-line max-len
-                msaLogger.debug('GracefulShutdownService.onModuleDestroy: waiting for interceptors to finish', { traceId: 'ON_MODULE_DESTROY' }, {
+                msaLogger.debug('GracefulShutdownService.waitForActiveInterceptors: waiting for interceptors to finish', { traceId: 'WAIT_FOR_INTERCEPTORS' }, {
                     activeInterceptors: this.activeInterceptors,
                     count,
+                    remainingCount: this.activeInterceptors.length,
+                    elapsedTime: Date.now() - startTime,
                 });
             }
             await new Promise((resolve) => {
                 setTimeout(resolve, 1000);
             });
         }
+        msaLogger.info('GracefulShutdownService.waitForActiveInterceptors: all interceptors finished', { traceId: 'WAIT_FOR_INTERCEPTORS' }, {
+            finalCount: count,
+            shutdownSignal: this.shutdownSignal,
+            totalElapsedTime: Date.now() - startTime,
+        });
     }
 };
 exports.GracefulShutdownService = GracefulShutdownService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yolo-croket-dev/core",
-  "version": "1.7.22",
+  "version": "1.7.24",
   "author": "Yolo Co., Ltd.",
   "description": "Yolo commonization module",
   "main": "index.js",