@yolo-croket-dev/core 1.7.44-slowquery.3 → 1.7.44-slowquery.5

package/functions/abort/context-promise-patch.d.ts

@@ -5,19 +5,12 @@ export declare class ContextPromisePatch {
     private static originalSetInterval;
     private static originalClearTimeout;
     private static originalClearInterval;
-    private static activeAbortListeners;
+    private static contextTimers;
+    private static timerContextMap;
     /**
-     * abort 리스너를 추적
+     * 특정 컨텍스트의 모든 타이머 정리
      */
-    static registerAbortListener(contextId: string): void;
-    /**
-     * abort 리스너 완료
-     */
-    static unregisterAbortListener(contextId: string): void;
-    /**
-     * 특정 컨텍스트의 모든 abort 리스너가 완료될 때까지 대기
-     */
-    static waitForAbortListeners(contextId: string, timeout?: number): Promise<void>;
+    static clearContextTimers(contextId: string): void;
     static patch(): void;
     private static patchPromise;
     private static patchTimeouts;

package/functions/abort/context-promise-patch.js

@@ -4,33 +4,17 @@ exports.ContextPromisePatch = void 0;
 const abort_context_1 = require("./abort-context");
 class ContextPromisePatch {
     /**
-     * abort 리스너를 추적
+     * 특정 컨텍스트의 모든 타이머 정리
      */
-    static registerAbortListener(contextId) {
-        this.activeAbortListeners.add(contextId);
-    }
-    /**
-     * abort 리스너 완료
-     */
-    static unregisterAbortListener(contextId) {
-        this.activeAbortListeners.delete(contextId);
-    }
-    /**
-     * 특정 컨텍스트의 모든 abort 리스너가 완료될 때까지 대기
-     */
-    static async waitForAbortListeners(contextId, timeout = 1000) {
-        const startTime = Date.now();
-        while (this.activeAbortListeners.has(contextId)) {
-            if (Date.now() - startTime > timeout) {
-                // 타임아웃
-                break;
+    static clearContextTimers(contextId) {
+        const timers = this.contextTimers.get(contextId);
+        if (timers) {
+            for (const timerId of timers) {
+                this.originalClearTimeout(timerId);
+                this.originalClearInterval(timerId);
+                this.timerContextMap.delete(timerId);
             }
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            await new Promise((resolve) => {
-                setTimeout(() => {
-                    resolve();
-                }, 10);
-            });
+            this.contextTimers.delete(contextId);
         }
     }
     static patch() {
@@ -182,14 +166,21 @@ class ContextPromisePatch {
                 contextId,
                 abortSignal,
             });
+            // 타이머 추적
+            if (!this.contextTimers.has(contextId)) {
+                this.contextTimers.set(contextId, new Set());
+            }
+            this.contextTimers.get(contextId).add(timeoutId);
+            this.timerContextMap.set(timeoutId, contextId);
+            // 클로저로 필요한 정보를 캡처 (컨텍스트가 disable되어도 동작)
+            const capturedContextId = contextId;
+            const capturedActiveTimers = activeTimers;
             const onAbort = () => {
-                ContextPromisePatch.registerAbortListener(contextId);
-                // 비동기로 처리해서 이벤트 루프에서 실행되도록 함
-                setTimeout(() => {
-                    this.originalClearTimeout(timeoutId);
-                    activeTimers.delete(timeoutId);
-                    ContextPromisePatch.unregisterAbortListener(contextId);
-                }, 0);
+                var _a;
+                this.originalClearTimeout(timeoutId);
+                capturedActiveTimers.delete(timeoutId);
+                (_a = this.contextTimers.get(capturedContextId)) === null || _a === void 0 ? void 0 : _a.delete(timeoutId);
+                this.timerContextMap.delete(timeoutId);
             };
             abortSignal.addEventListener('abort', onAbort, { once: true });
             return timeoutId;
@@ -234,14 +225,21 @@ class ContextPromisePatch {
                 contextId,
                 abortSignal,
             });
+            // 타이머 추적
+            if (!this.contextTimers.has(contextId)) {
+                this.contextTimers.set(contextId, new Set());
+            }
+            this.contextTimers.get(contextId).add(intervalId);
+            this.timerContextMap.set(intervalId, contextId);
+            // 클로저로 필요한 정보를 캡처 (컨텍스트가 disable되어도 동작)
+            const capturedContextId = contextId;
+            const capturedActiveTimers = activeTimers;
             const onAbort = () => {
-                ContextPromisePatch.registerAbortListener(contextId);
-                // 비동기로 처리해서 이벤트 루프에서 실행되도록 함
-                setTimeout(() => {
-                    this.originalClearInterval(intervalId);
-                    activeTimers.delete(intervalId);
-                    ContextPromisePatch.unregisterAbortListener(contextId);
-                }, 0);
+                var _a;
+                this.originalClearInterval(intervalId);
+                capturedActiveTimers.delete(intervalId);
+                (_a = this.contextTimers.get(capturedContextId)) === null || _a === void 0 ? void 0 : _a.delete(intervalId);
+                this.timerContextMap.delete(intervalId);
             };
             abortSignal.addEventListener('abort', onAbort, { once: true });
             return intervalId;
@@ -249,13 +247,25 @@ class ContextPromisePatch {
         // clearTimeout 패치
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         global.clearTimeout = (timerId) => {
+            var _a;
             activeTimers.delete(timerId);
+            const contextId = this.timerContextMap.get(timerId);
+            if (contextId) {
+                (_a = this.contextTimers.get(contextId)) === null || _a === void 0 ? void 0 : _a.delete(timerId);
+                this.timerContextMap.delete(timerId);
+            }
             this.originalClearTimeout(timerId);
         };
         // clearInterval 패치
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         global.clearInterval = (timerId) => {
+            var _a;
             activeTimers.delete(timerId);
+            const contextId = this.timerContextMap.get(timerId);
+            if (contextId) {
+                (_a = this.contextTimers.get(contextId)) === null || _a === void 0 ? void 0 : _a.delete(timerId);
+                this.timerContextMap.delete(timerId);
+            }
             this.originalClearInterval(timerId);
         };
     }
@@ -273,5 +283,9 @@ class ContextPromisePatch {
 }
 exports.ContextPromisePatch = ContextPromisePatch;
 ContextPromisePatch.isPatched = false;
-// abort 리스너 추적
-ContextPromisePatch.activeAbortListeners = new Set();
+// 컨텍스트별 활성 타이머 추적 (contextId -> Set<timerId>)
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+ContextPromisePatch.contextTimers = new Map();
+// timerId -> contextId 매핑
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+ContextPromisePatch.timerContextMap = new Map();

package/interceptors/rpc.interceptor.js

@@ -355,12 +355,15 @@ let RPCInterceptor = class RPCInterceptor {
                 }
             },
             error: localErrorProcessor,
-        }), (0, operators_1.finalize)(async () => {
+        }), (0, operators_1.finalize)(() => {
             this.gracefulShutdownService.popActiveInterceptors(execInterceptor);
-            // abort 이벤트 리스너가 모두 완료될 때까지 기다림
-            await context_promise_patch_1.ContextPromisePatch.waitForAbortListeners(execInterceptor.traceId);
-            functions_1.AbortContext.disable();
+            // 활성 타이머를 모두 정리
+            context_promise_patch_1.ContextPromisePatch.clearContextTimers(execInterceptor.traceId);
             abortController = null;
+            // disable을 충분히 지연시켜서 모든 이벤트 리스너가 완료될 때까지 기다림
+            setTimeout(() => {
+                functions_1.AbortContext.disable();
+            }, 100);
             return rxjs_1.EMPTY;
         })));
     }

package/package.json

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