@yolo-croket-dev/core 1.7.25-slowquery.3 → 1.7.25-slowquery.30

package/decorators/abort-event.decorator.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 이벤트 기반으로 AbortSignal을 감지하는 데코레이터 (Interval 없음)
+ */
+export declare function AbortEvent(): (target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/decorators/abort-event.decorator.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbortEvent = void 0;
+// src/modules/rpc-testing/decorators/abort-event.decorator.ts
+const abort_1 = require("../functions/abort");
+/**
+ * 이벤트 기반으로 AbortSignal을 감지하는 데코레이터 (Interval 없음)
+ */
+function AbortEvent() {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        // eslint-disable-next-line no-param-reassign
+        descriptor.value = async function (...args) {
+            // 중단 확인을 위한 인터벌
+            const intervalId = setInterval(() => {
+                (0, abort_1.throwIfAborted)();
+            }, 100);
+            try {
+                const result = await originalMethod.apply(this, args);
+                clearInterval(intervalId);
+                return result;
+            }
+            catch (error) {
+                clearInterval(intervalId);
+                throw error;
+            }
+        };
+        return descriptor;
+    };
+}
+exports.AbortEvent = AbortEvent;

package/decorators/index.d.ts

@@ -1,2 +1,3 @@
 export * from './rpc-interceptor-scope.decorator';
 export * from './rpc-transform.decorator';
+export * from './abort-event.decorator';

package/decorators/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./rpc-interceptor-scope.decorator"), exports);
 __exportStar(require("./rpc-transform.decorator"), exports);
+__exportStar(require("./abort-event.decorator"), exports);

package/functions/abort-context.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+/**
+ * AbortSignal을 AsyncLocalStorage를 통해 전역적으로 관리하는 컨텍스트
+ */
+export declare class AbortContext {
+    private static asyncLocalStorage;
+    /**
+     * AbortSignal과 함께 컨텍스트를 실행
+     * @param abortSignal 중단 신호
+     * @param requestId 요청 ID (디버깅용)
+     * @param callback 실행할 콜백 함수
+     * @returns 실행 결과
+     */
+    static run<T>(abortSignal: AbortSignal, requestId: string, callback: () => T): T;
+    /**
+     * 현재 컨텍스트의 AbortSignal을 가져옴
+     * @returns 현재 AbortSignal 또는 null
+     */
+    static getCurrentAbortSignal(): AbortSignal | null;
+    /**
+     * 현재 컨텍스트의 요청 ID를 가져옴
+     * @returns 현재 요청 ID 또는 null
+     */
+    static getCurrentRequestId(): string | null;
+    /**
+     * 현재 컨텍스트 정보를 가져옴
+     * @returns 현재 컨텍스트 또는 null
+     */
+    static getCurrentContext(): {
+        abortSignal: AbortSignal;
+        requestId: string;
+    } | null;
+}

package/functions/abort-context.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbortContext = void 0;
+const async_hooks_1 = require("async_hooks");
+/**
+ * AbortSignal을 AsyncLocalStorage를 통해 전역적으로 관리하는 컨텍스트
+ */
+class AbortContext {
+    /**
+     * AbortSignal과 함께 컨텍스트를 실행
+     * @param abortSignal 중단 신호
+     * @param requestId 요청 ID (디버깅용)
+     * @param callback 실행할 콜백 함수
+     * @returns 실행 결과
+     */
+    static run(abortSignal, requestId, callback) {
+        return this.asyncLocalStorage.run({
+            abortSignal,
+            requestId,
+        }, callback);
+    }
+    /**
+     * 현재 컨텍스트의 AbortSignal을 가져옴
+     * @returns 현재 AbortSignal 또는 null
+     */
+    static getCurrentAbortSignal() {
+        const context = this.asyncLocalStorage.getStore();
+        return (context === null || context === void 0 ? void 0 : context.abortSignal) || null;
+    }
+    /**
+     * 현재 컨텍스트의 요청 ID를 가져옴
+     * @returns 현재 요청 ID 또는 null
+     */
+    static getCurrentRequestId() {
+        const context = this.asyncLocalStorage.getStore();
+        return (context === null || context === void 0 ? void 0 : context.requestId) || null;
+    }
+    /**
+     * 현재 컨텍스트 정보를 가져옴
+     * @returns 현재 컨텍스트 또는 null
+     */
+    static getCurrentContext() {
+        return this.asyncLocalStorage.getStore() || null;
+    }
+}
+exports.AbortContext = AbortContext;
+AbortContext.asyncLocalStorage = new async_hooks_1.AsyncLocalStorage();

package/functions/abort.d.ts

@@ -0,0 +1,60 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/**
+ * 현재 컨텍스트의 AbortSignal을 가져오는 전역 함수
+ * @returns 현재 AbortSignal 또는 null
+ */
+export declare function getCurrentAbortSignal(): AbortSignal | null;
+/**
+ * 현재 AbortSignal이 중단되었는지 확인
+ * @returns 중단 여부
+ */
+export declare function isAborted(): boolean;
+/**
+ * AbortSignal이 중단되었을 때 에러를 던지는 함수
+ * @param message 에러 메시지
+ * @throws 중단된 경우 에러 발생
+ */
+export declare function throwIfAborted(message?: string): void;
+/**
+ * AbortSignal을 감지하여 중단 가능한 Promise를 생성
+ * @param promise 원본 Promise
+ * @param abortSignal 중단 신호 (선택사항, 없으면 현재 컨텍스트에서 가져옴)
+ * @returns 중단 가능한 Promise
+ */
+export declare function withAbortSignal<T>(promise: Promise<T>, abortSignal?: AbortSignal): Promise<T>;
+/**
+ * AbortSignal을 감지하여 중단 가능한 delay
+ * @param ms 지연 시간 (밀리초)
+ * @param abortSignal 중단 신호 (선택사항, 없으면 현재 컨텍스트에서 가져옴)
+ * @returns 중단 가능한 Promise
+ */
+export declare function delayWithAbort(ms: number, abortSignal?: AbortSignal): Promise<void>;
+/**
+ * AbortSignal을 감지하여 중단 가능한 setTimeout
+ * @param callback 실행할 콜백 함수
+ * @param delay 지연 시간 (밀리초)
+ * @param abortSignal 중단 신호 (선택사항, 없으면 현재 컨텍스트에서 가져옴)
+ * @returns 타이머 ID
+ */
+export declare function setTimeoutWithAbort(callback: () => void, delay: number, abortSignal?: AbortSignal): NodeJS.Timeout;
+/**
+ * AbortSignal을 감지하여 중단 가능한 반복 작업
+ * @param task 반복할 작업 함수
+ * @param interval 반복 간격 (밀리초)
+ * @param abortSignal 중단 신호 (선택사항, 없으면 현재 컨텍스트에서 가져옴)
+ * @returns 중단 가능한 Promise
+ */
+export declare function repeatWithAbort(task: () => Promise<void> | void, interval: number, abortSignal?: AbortSignal): Promise<void>;
+/**
+ * 현재 컨텍스트 정보를 로깅하는 디버그 함수
+ * @param message 로그 메시지
+ */
+export declare function logAbortContext(message: string): void;
+/**
+ * 이벤트 기반으로 중단 가능한 Promise 실행
+ * @param promise 원본 Promise
+ * @param abortSignal 중단 신호 (선택사항, 없으면 현재 컨텍스트에서 가져옴)
+ * @returns 중단 가능한 Promise
+ */
+export declare function withAbortSignalEventBased<T>(promise: Promise<T>, abortSignal?: AbortSignal): Promise<T>;

package/functions/abort.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withAbortSignalEventBased = exports.logAbortContext = exports.repeatWithAbort = exports.setTimeoutWithAbort = exports.delayWithAbort = exports.withAbortSignal = exports.throwIfAborted = exports.isAborted = exports.getCurrentAbortSignal = void 0;
+const abort_context_1 = require("./abort-context");
+/**
+ * 현재 컨텍스트의 AbortSignal을 가져오는 전역 함수
+ * @returns 현재 AbortSignal 또는 null
+ */
+function getCurrentAbortSignal() {
+    return abort_context_1.AbortContext.getCurrentAbortSignal();
+}
+exports.getCurrentAbortSignal = getCurrentAbortSignal;
+/**
+ * 현재 AbortSignal이 중단되었는지 확인
+ * @returns 중단 여부
+ */
+function isAborted() {
+    var _a;
+    const signal = getCurrentAbortSignal();
+    return (_a = signal === null || signal === void 0 ? void 0 : signal.aborted) !== null && _a !== void 0 ? _a : false;
+}
+exports.isAborted = isAborted;
+/**
+ * AbortSignal이 중단되었을 때 에러를 던지는 함수
+ * @param message 에러 메시지
+ * @throws 중단된 경우 에러 발생
+ */
+function throwIfAborted(message = '작업이 중단되었습니다') {
+    if (isAborted()) {
+        throw new Error(`REQUEST_ABORTED: ${message}`);
+    }
+}
+exports.throwIfAborted = throwIfAborted;
+/**
+ * AbortSignal을 감지하여 중단 가능한 Promise를 생성
+ * @param promise 원본 Promise
+ * @param abortSignal 중단 신호 (선택사항, 없으면 현재 컨텍스트에서 가져옴)
+ * @returns 중단 가능한 Promise
+ */
+function withAbortSignal(promise, abortSignal) {
+    const signal = abortSignal || getCurrentAbortSignal();
+    if (!signal) {
+        return promise;
+    }
+    return new Promise((resolve, reject) => {
+        // 이미 중단된 경우
+        if (signal.aborted) {
+            reject(new Error('REQUEST_ABORTED: 작업이 이미 중단되었습니다'));
+            return;
+        }
+        // 중단 이벤트 리스너 등록
+        const abortHandler = () => {
+            reject(new Error('REQUEST_ABORTED: 작업이 중단되었습니다'));
+        };
+        signal.addEventListener('abort', abortHandler, { once: true });
+        // 원본 Promise 처리
+        promise
+            .then((result) => {
+            signal.removeEventListener('abort', abortHandler);
+            resolve(result);
+        })
+            .catch((error) => {
+            signal.removeEventListener('abort', abortHandler);
+            reject(error);
+        });
+    });
+}
+exports.withAbortSignal = withAbortSignal;
+/**
+ * AbortSignal을 감지하여 중단 가능한 delay
+ * @param ms 지연 시간 (밀리초)
+ * @param abortSignal 중단 신호 (선택사항, 없으면 현재 컨텍스트에서 가져옴)
+ * @returns 중단 가능한 Promise
+ */
+function delayWithAbort(ms, abortSignal) {
+    const signal = abortSignal || getCurrentAbortSignal();
+    return new Promise((resolve, reject) => {
+        if (!signal) {
+            setTimeout(resolve, ms);
+            return;
+        }
+        // 이미 중단된 경우
+        if (signal.aborted) {
+            reject(new Error('REQUEST_ABORTED: 작업이 이미 중단되었습니다'));
+            return;
+        }
+        const timerId = setTimeout(() => {
+            if (!signal.aborted) {
+                resolve();
+            }
+        }, ms);
+        // 중단 이벤트 리스너 등록
+        const abortHandler = () => {
+            clearTimeout(timerId);
+            reject(new Error('REQUEST_ABORTED: 작업이 중단되었습니다'));
+        };
+        signal.addEventListener('abort', abortHandler, { once: true });
+    });
+}
+exports.delayWithAbort = delayWithAbort;
+/**
+ * AbortSignal을 감지하여 중단 가능한 setTimeout
+ * @param callback 실행할 콜백 함수
+ * @param delay 지연 시간 (밀리초)
+ * @param abortSignal 중단 신호 (선택사항, 없으면 현재 컨텍스트에서 가져옴)
+ * @returns 타이머 ID
+ */
+function setTimeoutWithAbort(callback, delay, abortSignal) {
+    const signal = abortSignal || getCurrentAbortSignal();
+    if (!signal) {
+        return setTimeout(callback, delay);
+    }
+    // 이미 중단된 경우
+    if (signal.aborted) {
+        throw new Error('REQUEST_ABORTED: 작업이 이미 중단되었습니다');
+    }
+    const timerId = setTimeout(() => {
+        if (!signal.aborted) {
+            callback();
+        }
+    }, delay);
+    // 중단 이벤트 리스너 등록
+    const abortHandler = () => {
+        clearTimeout(timerId);
+    };
+    signal.addEventListener('abort', abortHandler, { once: true });
+    return timerId;
+}
+exports.setTimeoutWithAbort = setTimeoutWithAbort;
+/**
+ * AbortSignal을 감지하여 중단 가능한 반복 작업
+ * @param task 반복할 작업 함수
+ * @param interval 반복 간격 (밀리초)
+ * @param abortSignal 중단 신호 (선택사항, 없으면 현재 컨텍스트에서 가져옴)
+ * @returns 중단 가능한 Promise
+ */
+function repeatWithAbort(task, interval, abortSignal) {
+    const signal = abortSignal || getCurrentAbortSignal();
+    return new Promise((resolve, reject) => {
+        if (!signal) {
+            // abortSignal이 없으면 일반적인 반복 실행
+            const runTask = async () => {
+                try {
+                    await task();
+                    setTimeout(runTask, interval);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            };
+            runTask();
+            return;
+        }
+        // 이미 중단된 경우
+        if (signal.aborted) {
+            reject(new Error('REQUEST_ABORTED: 작업이 이미 중단되었습니다'));
+            return;
+        }
+        const runTask = async () => {
+            if (signal.aborted) {
+                reject(new Error('REQUEST_ABORTED: 작업이 중단되었습니다'));
+                return;
+            }
+            try {
+                await task();
+                if (!signal.aborted) {
+                    setTimeout(runTask, interval);
+                }
+                else {
+                    reject(new Error('REQUEST_ABORTED: 작업이 중단되었습니다'));
+                }
+            }
+            catch (error) {
+                reject(error);
+            }
+        };
+        // 중단 이벤트 리스너 등록
+        const abortHandler = () => {
+            reject(new Error('REQUEST_ABORTED: 작업이 중단되었습니다'));
+        };
+        signal.addEventListener('abort', abortHandler, { once: true });
+        runTask();
+    });
+}
+exports.repeatWithAbort = repeatWithAbort;
+/**
+ * 현재 컨텍스트 정보를 로깅하는 디버그 함수
+ * @param message 로그 메시지
+ */
+function logAbortContext(message) {
+    var _a;
+    const context = abort_context_1.AbortContext.getCurrentContext();
+    // eslint-disable-next-line no-console
+    console.log(`[AbortContext] ${message}`, {
+        requestId: context === null || context === void 0 ? void 0 : context.requestId,
+        isAborted: (_a = context === null || context === void 0 ? void 0 : context.abortSignal) === null || _a === void 0 ? void 0 : _a.aborted,
+        hasSignal: !!(context === null || context === void 0 ? void 0 : context.abortSignal),
+    });
+}
+exports.logAbortContext = logAbortContext;
+/**
+ * 이벤트 기반으로 중단 가능한 Promise 실행
+ * @param promise 원본 Promise
+ * @param abortSignal 중단 신호 (선택사항, 없으면 현재 컨텍스트에서 가져옴)
+ * @returns 중단 가능한 Promise
+ */
+function withAbortSignalEventBased(promise, abortSignal) {
+    const signal = abortSignal || getCurrentAbortSignal();
+    if (!signal) {
+        return promise;
+    }
+    return new Promise((resolve, reject) => {
+        // 이미 중단된 경우
+        if (signal.aborted) {
+            reject(new Error('REQUEST_ABORTED: 작업이 이미 중단되었습니다'));
+            return;
+        }
+        let isCompleted = false;
+        // abort 이벤트 리스너 (즉시 반응)
+        const abortHandler = () => {
+            if (!isCompleted) {
+                isCompleted = true;
+                reject(new Error('REQUEST_ABORTED: 작업이 중단되었습니다'));
+            }
+        };
+        // 이벤트 리스너 등록
+        signal.addEventListener('abort', abortHandler, { once: true });
+        // 원본 Promise 처리
+        promise
+            .then((result) => {
+            if (!isCompleted) {
+                isCompleted = true;
+                signal.removeEventListener('abort', abortHandler);
+                resolve(result);
+            }
+        })
+            .catch((error) => {
+            if (!isCompleted) {
+                isCompleted = true;
+                signal.removeEventListener('abort', abortHandler);
+                reject(error);
+            }
+        });
+    });
+}
+exports.withAbortSignalEventBased = withAbortSignalEventBased;

package/functions/index.d.ts

@@ -4,3 +4,5 @@ export * from './amqp-publish.function';
 export * from './rewrite-file-value.function';
 export * from './amqp-call-manager.function';
 export * from './extract-redis-url.function';
+export * from './abort';
+export * from './abort-context';

package/functions/index.js

@@ -20,3 +20,5 @@ __exportStar(require("./amqp-publish.function"), exports);
 __exportStar(require("./rewrite-file-value.function"), exports);
 __exportStar(require("./amqp-call-manager.function"), exports);
 __exportStar(require("./extract-redis-url.function"), exports);
+__exportStar(require("./abort"), exports);
+__exportStar(require("./abort-context"), exports);

package/interceptors/logging-service.interceptor.js

@@ -188,7 +188,7 @@ let LoggingServiceInterceptor = class LoggingServiceInterceptor {
         }));
     }
 };
-LoggingServiceInterceptor = __decorate([
+exports.LoggingServiceInterceptor = LoggingServiceInterceptor;
+exports.LoggingServiceInterceptor = LoggingServiceInterceptor = __decorate([
     (0, common_1.Injectable)()
 ], LoggingServiceInterceptor);
-exports.LoggingServiceInterceptor = LoggingServiceInterceptor;

package/interceptors/rpc.interceptor.d.ts

@@ -5,6 +5,8 @@ import { GracefulShutdownService } from '../modules/graceful-shutdown/graceful-s
 export declare class RPCInterceptor implements NestInterceptor {
     private readonly reflector;
     private readonly gracefulShutdownService;
+    protected readonly DEFAULT_TIMEOUT = 1000;
+    protected readonly DEFAULT_TIMEOUT_MESSAGE = "\uC694\uCCAD\uC774 \uD0C0\uC784\uC544\uC6C3\uB418\uC5C8\uC2B5\uB2C8\uB2E4.";
     constructor(reflector: Reflector, gracefulShutdownService: GracefulShutdownService);
     private maxLengthOverShorten;
     /** 메시지가 재전송되었을때에, 재시도 Count가 명시되어 있지 않을때에 처리 할지 여부를 결정하는 함수 */

package/interceptors/rpc.interceptor.js

@@ -44,11 +44,9 @@ const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
 const msa_logger_1 = __importStar(require("@yolo-croket-dev/msa-logger"));
 const amqplib_1 = __importDefault(require("amqplib"));
-// import Logger from '@yolo-croket-dev/logger';
 const functions_1 = require("../functions");
 const exceptions_1 = require("../exceptions");
 const graceful_shutdown_service_1 = require("../modules/graceful-shutdown/graceful-shutdown.service");
-// const logger = Logger.createLogger('RPCInterceptor');
 const msaLogger = new msa_logger_1.default(msa_logger_1.ServerTypeEnum.SERVICE);
 // const MAX_CUT_LENGTH = 500;
 const MAX_LENGTH = 300;
@@ -56,6 +54,9 @@ let RPCInterceptor = class RPCInterceptor {
     constructor(reflector, gracefulShutdownService) {
         this.reflector = reflector;
         this.gracefulShutdownService = gracefulShutdownService;
+        this.DEFAULT_TIMEOUT = 1000; // 29분 타임아웃
+        // protected readonly DEFAULT_TIMEOUT = 1000 * 60 * 29; // 29분 타임아웃
+        this.DEFAULT_TIMEOUT_MESSAGE = '요청이 타임아웃되었습니다.';
     }
     maxLengthOverShorten(data) {
         if (typeof data !== 'string') {
@@ -146,48 +147,12 @@ let RPCInterceptor = class RPCInterceptor {
         }
         return obj;
     }
-    // private keyCutter(data: string) {
-    //   try {
-    //     if (data) {
-    //       data = JSON.parse(data);
-    //     } else {
-    //       return data;
-    //     }
-    //   } catch (err) {
-    //     return data;
-    //   }
-    //   for (const key of Object.keys(data)) {
-    //     const type = typeof data[key as any];
-    //     if (type === 'string') {
-    //       if (data[key as any].length > MAX_CUT_LENGTH) {
-    //         (data[key as any] as any) = `${data[key as any].slice(0, MAX_CUT_LENGTH)}...`;
-    //       }
-    //     } else if (type === 'object') {
-    //       if (data[key as any] === null) {
-    //         (data[key as any] as any) = null;
-    //       } else {
-    //         (data[key as any] as any) = this.keyCutter(data[key as any]);
-    //       }
-    //     }
-    //   }
-    //   return data;
-    // }
     async intercept(context, next) {
         var _a, _b, _c, _d, _e;
         const options = this.reflector.get('rpcInterceptorScope', context.getHandler());
         const args = context.getArgs();
         const arg = args[0];
         const rmq = args[1];
-        // 메시지에서 AbortController 가져오기
-        const abortController = rmq.args[0].abortController;
-        //  const messageId = (rmq as any).messageId;
-        //  if (!abortController) {
-        //    // AbortController가 없으면 기본 처리
-        //    return next.handle().pipe(
-        //      timeout(1000 * 60 * 29),
-        //      // ... 기존 로직
-        //    );
-        //  }
         const channel = rmq.getChannelRef();
         const message = rmq.getMessage();
         const now = Date.now();
@@ -204,6 +169,7 @@ let RPCInterceptor = class RPCInterceptor {
             correlationId,
             isMessageAck: false,
         };
+        const abortController = new AbortController();
         /** consume 메시지 전부 cancel */
         if (this.gracefulShutdownService.isApplicationExit) {
             msaLogger.debug('RPCInterceptor isApplicationExit called', { traceId: 'IS_APPLICATION_EXIT' });
@@ -264,13 +230,6 @@ let RPCInterceptor = class RPCInterceptor {
                 errMessage,
                 errAction,
             };
-            // const isTimeoutError = err instanceof Error && err.name === 'TimeoutError';
-            // if (isTimeoutError) {
-            //   channel.nack(message, false, true);
-            //   message.properties.replyTo = undefined; /** replyTo가 존재하면 sendToQueue가 호출되므로, 삭제해주기 */
-            //   execInterceptor.isMessageAck = true;
-            //   return EMPTY;
-            // }
             if (!Number.isNaN(staticRetryCount)
                 && staticRetryCount
                 && err.isRetry !== false) {
@@ -303,11 +262,6 @@ let RPCInterceptor = class RPCInterceptor {
             const messageContent = message.content.toString();
             /** 파일 객체 처리 */
             (0, functions_1.reWriteFileValue)((_a = messageContent === null || messageContent === void 0 ? void 0 : messageContent.data) === null || _a === void 0 ? void 0 : _a.file);
-            // logger.debug(`<= (error:${traceId}): ${JSON.stringify(sendMessage.toString())}`, {
-            //   ...logParam,
-            //   duration,
-            //   isError: true,
-            // });
             if (!noAck && !isAck) {
                 channel.ack(message);
                 execInterceptor.isMessageAck = true;
@@ -336,39 +290,32 @@ let RPCInterceptor = class RPCInterceptor {
                 return new rxjs_1.Observable();
             }
         }
-        if (content.pattern === 'UPLOAD_FILE') {
-            if (content.data.payload.file) {
-                content.data.payload.file = `${content.data.payload.file.slice(0, 30)}...`;
-            }
-            // logger.debug(`=> (${traceId}): ${JSON.stringify(this.keyCutter(JSON.stringify(content)))}`);
-        }
-        else {
-            // logger.debug(`=> (${traceId}): ${JSON.stringify(this.keyCutter(JSON.stringify(content)))}`);
-        }
         this.gracefulShutdownService.pushActiveInterceptors(execInterceptor);
         // eslint-disable-next-line consistent-return
-        return next
+        return functions_1.AbortContext.run(abortController.signal, execInterceptor.traceId, () => next
             .handle()
-            .pipe(
-        // AbortController 신호 감지
-        (0, operators_1.takeUntil)(new rxjs_1.Observable(subscriber => {
-            const abortHandler = () => {
-                console.log('RPC Interceptor abortHandler called');
-                subscriber.next();
-                subscriber.complete();
-            };
-            console.log('RPC Interceptor abortHandler addEventListener');
-            abortController.signal.addEventListener('abort', abortHandler, { once: true });
-            // 정리 함수
-            return () => {
-                abortController.signal.removeEventListener('abort', abortHandler);
-            };
-        })), 
-        // timeout(1000 * 60 * 29), // 30분 타임아웃
-        (0, operators_1.timeout)(1000 * 30), // 30분 타임아웃
-        (0, operators_1.tap)({
+            .pipe((0, operators_1.timeout)({
+            each: this.DEFAULT_TIMEOUT,
+            with: () => {
+                console.log('RPCInterceptor timeout 발생');
+                msaLogger.error('RPCInterceptor timeout 발생', { traceId: execInterceptor.traceId }, { message: this.DEFAULT_TIMEOUT_MESSAGE });
+                abortController.abort();
+                return (0, rxjs_1.throwError)(() => new Error(this.DEFAULT_TIMEOUT_MESSAGE));
+            },
+        }), (0, operators_1.catchError)((error) => {
+            // eslint-disable-next-line no-console
+            console.log('AbortInterceptor: 에러 발생', {
+                error: error.message,
+                isAborted: abortController.signal.aborted,
+            });
+            // abort된 경우와 일반 에러를 구분
+            if (abortController.signal.aborted) {
+                // 추가되어야 하는가?
+                return (0, rxjs_1.throwError)(() => new Error(`REQUEST_ABORTED: ${this.DEFAULT_TIMEOUT_MESSAGE}`));
+            }
+            return (0, rxjs_1.throwError)(() => error);
+        }), (0, operators_1.tap)({
             next: async (val) => {
-                console.log('RPC Interceptor next called');
                 val.isError = false;
                 // const duration = Date.now() - now;
                 // logger.debug(`<= (success:${traceId}): ${val.message}`, {
@@ -392,12 +339,9 @@ let RPCInterceptor = class RPCInterceptor {
         // eslint-disable-next-line consistent-return
         (0, operators_1.catchError)(async (err) => {
             // timeout 에러 처리
-            const isTimeoutError = err instanceof Error && err.name === 'TimeoutError';
+            console.log('RPCInterceptor catchError 발생', err);
+            const isTimeoutError = err instanceof Error && (err.name === 'TimeoutError' || err.message === this.DEFAULT_TIMEOUT_MESSAGE);
             if (isTimeoutError) {
-                if (abortController) {
-                    abortController.abort();
-                    throw new Error('Message aborted due to timeout');
-                }
                 msaLogger.error('[타임 아웃] 메시지 재전송 처리', { traceId: execInterceptor.traceId }, {
                     error: {
                         message: err.message,
@@ -427,12 +371,12 @@ let RPCInterceptor = class RPCInterceptor {
             }
         }), (0, operators_1.finalize)(() => {
             this.gracefulShutdownService.popActiveInterceptors(execInterceptor);
-        }));
+        })));
     }
 };
-RPCInterceptor = __decorate([
+exports.RPCInterceptor = RPCInterceptor;
+exports.RPCInterceptor = RPCInterceptor = __decorate([
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [core_1.Reflector,
         graceful_shutdown_service_1.GracefulShutdownService])
 ], RPCInterceptor);
-exports.RPCInterceptor = RPCInterceptor;

package/interfaces/exception.js

@@ -18,9 +18,10 @@ var ErrActionTypeEnum;
     ErrActionTypeEnum["LEGACY_SHOW_TOAST"] = "LEGACY_SHOW_TOAST";
     ErrActionTypeEnum["FORCE_UPDATE"] = "FORCE_UPDATE";
     ErrActionTypeEnum["UPDATE_ACCESS_TOKEN"] = "UPDATE_ACCESS_TOKEN";
-})(ErrActionTypeEnum = exports.ErrActionTypeEnum || (exports.ErrActionTypeEnum = {}));
+})(ErrActionTypeEnum || (exports.ErrActionTypeEnum = ErrActionTypeEnum = {}));
 class ErrAction {
 }
+exports.ErrAction = ErrAction;
 __decorate([
     (0, swagger_1.ApiProperty)({
         description: '액션 타입',
@@ -57,9 +58,9 @@ __decorate([
     }),
     __metadata("design:type", String)
 ], ErrAction.prototype, "webViewUrl", void 0);
-exports.ErrAction = ErrAction;
 class ErrInfo {
 }
+exports.ErrInfo = ErrInfo;
 __decorate([
     (0, swagger_1.ApiProperty)({
         description: '에러 종류 식별자',
@@ -81,4 +82,3 @@ __decorate([
     }),
     __metadata("design:type", ErrAction)
 ], ErrInfo.prototype, "action", void 0);
-exports.ErrInfo = ErrInfo;

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

@@ -25,7 +25,8 @@ let GracefulShutdownModule = class GracefulShutdownModule {
         }
     }
 };
-GracefulShutdownModule = __decorate([
+exports.GracefulShutdownModule = GracefulShutdownModule;
+exports.GracefulShutdownModule = GracefulShutdownModule = __decorate([
     (0, common_1.Global)(),
     (0, common_1.Module)({
         providers: [graceful_shutdown_service_1.GracefulShutdownService],
@@ -33,4 +34,3 @@ GracefulShutdownModule = __decorate([
     }),
     __metadata("design:paramtypes", [graceful_shutdown_service_1.GracefulShutdownService])
 ], GracefulShutdownModule);
-exports.GracefulShutdownModule = GracefulShutdownModule;

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

@@ -1,7 +1,7 @@
 import { RmqOptions, ServerRMQ } from '@nestjs/microservices';
 import { Channel } from 'amqp-connection-manager';
 import { ConsumeMessage } from 'amqplib';
-export declare type GracefulRmqOptions = RmqOptions['options'] & {
+export type GracefulRmqOptions = RmqOptions['options'] & {
     waitingEndingHandlersTimeoutMs?: number;
     waitingEndingHandlersIntervalMs?: number;
 };

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

@@ -6,8 +6,6 @@ const node_util_1 = require("node:util");
 const sleep = (0, node_util_1.promisify)(setTimeout);
 const RMQ_DEFAULT_WAITING_ENDING_HANDLERS_TIMEOUT_MS = 5000;
 const RMQ_DEFAULT_WAITING_ENDING_HANDLERS_INTERVAL_MS = 500;
-// const RMQ_DEFAULT_MESSAGE_TIMEOUT_MS = 1000 * 60 * 29; // 29분
-const RMQ_DEFAULT_MESSAGE_TIMEOUT_MS = 1000 * 2; // 2분
 class GracefulServerRMQ extends microservices_1.ServerRMQ {
     constructor(options) {
         super(options);
@@ -38,58 +36,10 @@ class GracefulServerRMQ extends microservices_1.ServerRMQ {
         }
     }
     async handleMessage(message, channel) {
-        const messageId = message.properties.messageId || message.properties.correlationId || `msg_${Date.now()}_${Math.random()}`;
-        // AbortController 생성
-        const abortController = new AbortController();
-        // 타임아웃 설정
-        const timeoutId = setTimeout(() => {
-            console.log(`Message timeout: ${messageId}`);
-            abortController.abort();
-        }, RMQ_DEFAULT_MESSAGE_TIMEOUT_MS);
-        console.log('timeout 설정', timeoutId);
         this.runningMessages += 1;
-        try {
-            // AbortController를 메시지에 추가
-            // eslint-disable-next-line no-param-reassign, @typescript-eslint/no-explicit-any
-            message.abortController = abortController;
-            // eslint-disable-next-line no-param-reassign
-            message.messageId = messageId;
-            // abort 상태 확인
-            if (abortController.signal.aborted) {
-                console.log(`Message already aborted: ${messageId}`);
-                this.runningMessages -= 1;
-                return;
-            }
-            // Promise.race를 사용하여 abort와 handleMessage 경쟁
-            const handleMessagePromise = super.handleMessage(message, channel);
-            const abortPromise = new Promise((_, reject) => {
-                // 1초마다 abort 상태를 확인
-                const interval = setInterval(() => {
-                    if (abortController.signal.aborted) {
-                        reject(new Error(`Message aborted: ${messageId}`));
-                        clearInterval(interval);
-                    }
-                }, 1000);
-            });
-            // 둘 중 하나가 먼저 완료되면 그 결과를 반환
-            await Promise.race([
-                handleMessagePromise,
-                abortPromise,
-            ]);
-        }
-        catch (error) {
-            if (error.message.includes('Message aborted')) {
-                console.log(`Message processing aborted: ${messageId}`);
-                // abort로 인한 에러는 정상적으로 처리된 것으로 간주
-            }
-            else {
-                throw error;
-            }
-        }
-        finally {
+        return super.handleMessage(message, channel).finally(() => {
             this.runningMessages -= 1;
-            clearTimeout(timeoutId);
-        }
+        });
     }
     async close() {
         this.closing = true;

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

@@ -137,7 +137,7 @@ let GracefulShutdownService = class GracefulShutdownService {
         });
     }
 };
-GracefulShutdownService = __decorate([
+exports.GracefulShutdownService = GracefulShutdownService;
+exports.GracefulShutdownService = GracefulShutdownService = __decorate([
     (0, common_1.Injectable)()
 ], GracefulShutdownService);
-exports.GracefulShutdownService = GracefulShutdownService;

package/modules/redis.module.js

@@ -15,10 +15,10 @@ const redisProvider = {
 };
 let RedisModule = class RedisModule {
 };
-RedisModule = __decorate([
+exports.RedisModule = RedisModule;
+exports.RedisModule = RedisModule = __decorate([
     (0, common_1.Module)({
         providers: [redisProvider],
         exports: [redisProvider],
     })
 ], RedisModule);
-exports.RedisModule = RedisModule;

package/package.json

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

package/pipes/rpc-validation.pipe.js

@@ -31,8 +31,8 @@ let ValidationPipe = class ValidationPipe {
         return value;
     }
 };
-ValidationPipe = __decorate([
+exports.ValidationPipe = ValidationPipe;
+exports.ValidationPipe = ValidationPipe = __decorate([
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [Object])
 ], ValidationPipe);
-exports.ValidationPipe = ValidationPipe;