@yolo-croket-dev/core 1.10.4 → 1.10.5

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 1.10.5
+
+- 종료 중 RPC의 consumer 취소나 메시지 반환이 실패해도 기존 Pod의 오류·완료 응답으로 전파하지 않습니다.
+- 취소 실패 후에도 메시지 반환을 시도하며 실패한 작업은 요청 traceId와 정리된 진단 정보로 한 번 기록합니다.
+
 ## 1.10.4
 
 - 종료 중 consumer 취소나 채널 설정이 실패해도 기존 RPC 완료 대기와 최종 연결 정리를 계속합니다.

package/interceptors/rpc.interceptor.js

@@ -148,10 +148,39 @@ let RPCInterceptor = class RPCInterceptor {
         }
         return obj;
     }
-    async requeueMessageOnShutdown(channel, message) {
+    async requeueMessageOnShutdown(channel, message, traceId) {
         msaLogger.debug('RPCInterceptor isApplicationExit called', { traceId: 'IS_APPLICATION_EXIT' });
-        await channel.cancel(message.fields.consumerTag);
-        channel.nack(message, false, true);
+        const failures = [];
+        try {
+            await channel.cancel(message.fields.consumerTag);
+        }
+        catch (err) {
+            failures.push({
+                operation: 'cancel',
+                diagnostic: (0, msa_logger_1.normalizeDiagnosticError)(err),
+            });
+        }
+        try {
+            channel.nack(message, false, true);
+        }
+        catch (err) {
+            // 닫힌 채널의 미확인 메시지는 브로커가 재전달하므로 기존 Pod에서 오류 응답을 보내지 않는다.
+            failures.push({
+                operation: 'nack',
+                diagnostic: (0, msa_logger_1.normalizeDiagnosticError)(err),
+            });
+        }
+        if (failures.length) {
+            msaLogger.warn('RPCInterceptor 종료 중 메시지 재전달 처리 실패', {
+                traceId,
+                diagnosticInfo: failures[0].diagnostic.diagnosticInfo,
+            }, {
+                failures: failures.map(({ operation, diagnostic }) => ({
+                    operation,
+                    ...diagnostic.details,
+                })),
+            });
+        }
         // 기존 서버에서 응답을 완료하면 재전달된 요청의 실제 응답을 클라이언트가 기다릴 수 없다.
         return new rxjs_1.Observable();
     }
@@ -182,7 +211,7 @@ let RPCInterceptor = class RPCInterceptor {
         let abortController = new AbortController();
         /** consume 메시지 전부 cancel */
         if (this.gracefulShutdownService.isApplicationExit) {
-            return this.requeueMessageOnShutdown(channel, message);
+            return this.requeueMessageOnShutdown(channel, message, execInterceptor.traceId);
         }
         if (!staticRetryCount && reDeliveryCount > 0) {
             msaLogger.debug('RETRY_COUNT_ZERO_OR_NO_RETRY 발생 전, redelivery 발생', { traceId: ((_b = content.data.param) === null || _b === void 0 ? void 0 : _b.traceId) || 'RETRY_COUNT_ZERO_OR_NO_RETRY' }, {
@@ -195,7 +224,7 @@ let RPCInterceptor = class RPCInterceptor {
             });
             const isRedeliveryMessage = await this.isRedeliveryMessage(message.properties.replyTo, execInterceptor.traceId);
             if (this.gracefulShutdownService.isApplicationExit) {
-                return this.requeueMessageOnShutdown(channel, message);
+                return this.requeueMessageOnShutdown(channel, message, execInterceptor.traceId);
             }
             if (!isRedeliveryMessage || reDeliveryCount > 5) {
                 msaLogger.debug('isRedeliveryMessage RETRY_COUNT_ZERO_OR_NO_RETRY false', { traceId: ((_c = content.data.param) === null || _c === void 0 ? void 0 : _c.traceId) || 'RETRY_COUNT_ZERO_OR_NO_RETRY' });
@@ -368,7 +397,7 @@ let RPCInterceptor = class RPCInterceptor {
         }
         // 재전달 여부를 비동기로 확인하는 동안 종료가 시작될 수 있으므로 실행 직전에 다시 확인한다.
         if (this.gracefulShutdownService.isApplicationExit) {
-            return this.requeueMessageOnShutdown(channel, message);
+            return this.requeueMessageOnShutdown(channel, message, execInterceptor.traceId);
         }
         this.gracefulShutdownService.pushActiveInterceptors(execInterceptor);
         // eslint-disable-next-line consistent-return

package/package.json

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

package/tests/rmq-shutdown-requeue.test.cjs

@@ -2,6 +2,9 @@ const assert = require('node:assert/strict');
 const test = require('node:test');
 const { createRequire } = require('node:module');
 const { RmqContext, ServerRMQ } = require('@nestjs/microservices');
+const { RpcProxy } = require('@nestjs/microservices/context/rpc-proxy');
+const { RpcExceptionsHandler } = require('@nestjs/microservices/exceptions/rpc-exceptions-handler');
+const { Logger } = require('@nestjs/common');
 const { callModuleDestroyHook } = require('@nestjs/core/hooks/on-module-destroy.hook');
 const { InstanceWrapper } = require('@nestjs/core/injector/instance-wrapper');
 const { Subject } = require('rxjs');
@@ -49,6 +52,60 @@ test('종료 중 받은 미실행 RPC는 즉시 재전달하고 기존 요청의
   assert.equal(shutdown.getActiveInterceptorsCount(), 0);
 });
 
+for (const scenario of [
+  { name: '취소 실패', cancelFails: true, nackFails: false, duringRedelivery: false },
+  { name: '반환 실패', cancelFails: false, nackFails: true, duringRedelivery: false },
+  { name: '취소·반환 실패', cancelFails: true, nackFails: true, duringRedelivery: false },
+  { name: '재전달 확인 중 종료와 취소 실패', cancelFails: true, nackFails: false, duringRedelivery: true },
+]) {
+  test(`${scenario.name} 시에도 기존 Pod는 RPC 오류나 완료 응답을 보내지 않는다`, async t => {
+    t.mock.method(MsaLogger.prototype, 'debug', () => {});
+    t.mock.method(Logger.prototype, 'error', () => {});
+    const warning = t.mock.method(MsaLogger.prototype, 'warn', () => {});
+    const shutdown = new GracefulShutdownService();
+    shutdown.isApplicationExit = !scenario.duringRedelivery;
+    const calls = [];
+    const channel = {
+      cancel: async () => {
+        calls.push('cancel');
+        if (scenario.cancelFails) throw Error('channel closed during cancel');
+      },
+      nack: (_message, multiple, requeue) => {
+        calls.push(['nack', multiple, requeue]);
+        if (scenario.nackFails) throw Error('channel closed during nack');
+      },
+    };
+    const { message, context } = createRequest(channel, scenario.duringRedelivery ? { 'x-delivery-count': 1 } : {});
+    const interceptor = new RPCInterceptor({ get: () => undefined }, shutdown);
+    if (scenario.duringRedelivery) {
+      const server = new GracefulServerRMQ({ queue: 'TEST', noAck: false });
+      shutdown.registerRmqServer(server);
+      t.mock.method(interceptor, 'isRedeliveryMessage', async () => {
+        await shutdown.onModuleDestroy();
+        return true;
+      });
+    }
+    const next = { handle: t.mock.fn(() => { throw Error('실행하면 안 되는 신규 요청'); }) };
+    const handler = new RpcProxy().create(() => interceptor.intercept(context, next), new RpcExceptionsHandler());
+    const response = await handler(...context.getArgs());
+    const replies = [];
+    const subscription = new ServerRMQ({ queue: 'TEST', noAck: false }).send(response, value => replies.push(value));
+    t.after(() => subscription.unsubscribe());
+    await new Promise(resolve => setImmediate(resolve));
+    assert.deepEqual(replies, []);
+    assert.deepEqual(calls, ['cancel', ['nack', false, true]]);
+    assert.equal(next.handle.mock.callCount(), 0);
+    assert.equal(shutdown.getActiveInterceptorsCount(), 0);
+    assert.equal(warning.mock.callCount(), 1);
+    const [logMessage, logInfo, logDetails] = warning.mock.calls[0].arguments;
+    assert.match(logMessage, /종료/);
+    assert.equal(logInfo.traceId, 'shutdown-test');
+    assert.deepEqual(logDetails.failures.map(item => item.operation),
+      [scenario.cancelFails ? 'cancel' : null, scenario.nackFails ? 'nack' : null].filter(Boolean));
+    assert.equal(message.properties.replyTo, 'reply-queue');
+  });
+}
+
 test('종료 전에 실행한 RPC는 계속 처리하고 종료 이후 도착한 메시지만 반환한다', async t => {
   t.mock.method(MsaLogger.prototype, 'debug', () => {});
   const shutdown = new GracefulShutdownService();