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

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

@@ -8,6 +8,7 @@ interface RequestContext {
 export declare class AbortContext {
     private static asyncLocalStorage;
     private static contextCounter;
+    private static pendingAbortCallbacks;
     static run<T>(abortSignal: AbortSignal, requestId: string, callback: (context: RequestContext) => T): T;
     static getCurrentAbortSignal(): AbortSignal | null;
     static getCurrentRequestId(): string | null;
@@ -15,6 +16,14 @@ export declare class AbortContext {
         abortSignal: AbortSignal;
         requestId: string;
     } | null;
+    /**
+     * 컨텍스트 종료 전에 모든 abort 이벤트 리스너가 완료될 때까지 대기
+     */
+    static waitForAbortHandlers(requestId: string): Promise<void>;
+    /**
+     * 이 컨텍스트의 모든 abort 이벤트 처리 완료 후 disable 호출
+     */
+    static disableAfterAbortHandlers(requestId: string): Promise<void>;
     static disable(): void;
     static disableDeferred(): void;
     static endContext(context?: RequestContext): void;

package/functions/abort/abort-context.js

@@ -12,6 +12,35 @@ class AbortContext {
             createdAt: Date.now(),
             parentContext: currentContext || undefined,
         };
+        // abort 이벤트가 발생할 때까지 대기하는 Promise 생성
+        const abortPromise = new Promise((resolve) => {
+            const checkAbortStatus = () => {
+                if (abortSignal.aborted) {
+                    // 이벤트 루프를 두 번 통과시켜서 모든 abort 리스너가 완료되도록 보장
+                    setTimeout(() => {
+                        setTimeout(() => {
+                            resolve();
+                        }, 0);
+                    }, 0);
+                }
+                else {
+                    // 아직 abort가 발생하지 않았으면 즉시 resolve
+                    resolve();
+                }
+            };
+            abortSignal.addEventListener('abort', checkAbortStatus, { once: true });
+            // abort 이벤트가 이미 발생했는지 확인
+            if (abortSignal.aborted) {
+                checkAbortStatus();
+            }
+            else {
+                // abort가 발생하지 않은 상태라면 즉시 resolve
+                setTimeout(() => {
+                    resolve();
+                }, 0);
+            }
+        });
+        this.pendingAbortCallbacks.set(newContext.requestId, abortPromise);
         return this.asyncLocalStorage.run(newContext, callback.bind(this, newContext));
     }
     static getCurrentAbortSignal() {
@@ -32,6 +61,23 @@ class AbortContext {
         }
         return null;
     }
+    /**
+     * 컨텍스트 종료 전에 모든 abort 이벤트 리스너가 완료될 때까지 대기
+     */
+    static async waitForAbortHandlers(requestId) {
+        const promise = this.pendingAbortCallbacks.get(requestId);
+        if (promise) {
+            await promise;
+            this.pendingAbortCallbacks.delete(requestId);
+        }
+    }
+    /**
+     * 이 컨텍스트의 모든 abort 이벤트 처리 완료 후 disable 호출
+     */
+    static async disableAfterAbortHandlers(requestId) {
+        await this.waitForAbortHandlers(requestId);
+        this.asyncLocalStorage.disable();
+    }
     static disable() {
         this.asyncLocalStorage.disable();
     }
@@ -94,3 +140,5 @@ class AbortContext {
 exports.AbortContext = AbortContext;
 AbortContext.asyncLocalStorage = new async_hooks_1.AsyncLocalStorage();
 AbortContext.contextCounter = 0;
+// abort 이벤트 처리를 추적하기 위한 Map
+AbortContext.pendingAbortCallbacks = new Map();

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

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

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

@@ -3,6 +3,36 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            await new Promise((resolve) => {
+                setTimeout(() => {
+                    resolve();
+                }, 10);
+            });
+        }
+    }
     static patch() {
         if (this.isPatched) {
             return;
@@ -153,8 +183,13 @@ class ContextPromisePatch {
                 abortSignal,
             });
             const onAbort = () => {
-                this.originalClearTimeout(timeoutId);
-                activeTimers.delete(timeoutId);
+                ContextPromisePatch.registerAbortListener(contextId);
+                // 비동기로 처리해서 이벤트 루프에서 실행되도록 함
+                setTimeout(() => {
+                    this.originalClearTimeout(timeoutId);
+                    activeTimers.delete(timeoutId);
+                    ContextPromisePatch.unregisterAbortListener(contextId);
+                }, 0);
             };
             abortSignal.addEventListener('abort', onAbort, { once: true });
             return timeoutId;
@@ -200,8 +235,13 @@ class ContextPromisePatch {
                 abortSignal,
             });
             const onAbort = () => {
-                this.originalClearInterval(intervalId);
-                activeTimers.delete(intervalId);
+                ContextPromisePatch.registerAbortListener(contextId);
+                // 비동기로 처리해서 이벤트 루프에서 실행되도록 함
+                setTimeout(() => {
+                    this.originalClearInterval(intervalId);
+                    activeTimers.delete(intervalId);
+                    ContextPromisePatch.unregisterAbortListener(contextId);
+                }, 0);
             };
             abortSignal.addEventListener('abort', onAbort, { once: true });
             return intervalId;
@@ -233,3 +273,5 @@ class ContextPromisePatch {
 }
 exports.ContextPromisePatch = ContextPromisePatch;
 ContextPromisePatch.isPatched = false;
+// abort 리스너 추적
+ContextPromisePatch.activeAbortListeners = new Set();

package/interceptors/rpc.interceptor.js

@@ -355,9 +355,11 @@ let RPCInterceptor = class RPCInterceptor {
                 }
             },
             error: localErrorProcessor,
-        }), (0, operators_1.finalize)(() => {
+        }), (0, operators_1.finalize)(async () => {
             this.gracefulShutdownService.popActiveInterceptors(execInterceptor);
-            functions_1.AbortContext.disableDeferred();
+            // abort 이벤트 리스너가 모두 완료될 때까지 기다림
+            await context_promise_patch_1.ContextPromisePatch.waitForAbortListeners(execInterceptor.traceId);
+            functions_1.AbortContext.disable();
             abortController = null;
             return rxjs_1.EMPTY;
         })));

package/package.json

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